1、基本数据类型对象包装类:见下图
public class Test {
public static void main(String[] args){
Demo();
toStringDemo();
jdkDemo();
}
private static void jdkDemo() {
//注意:在1.5之后的版本中可以使用下面的形式 简化书写 ,这是版本升级的一个方面
Integer i=3; //自动装箱,jdk是Integer i = Integer.valueOf(3);
i=i+3; //自动拆箱,
/*注意:和用new生成对象的小区别是,
* 简写书写时如果数值在一个字节以内(即<128)时,重复生成不产生新空间
*/
Integer a=127;
Integer b=127;
System.out.println(a==b);
System.out.println(a.equals(b));
Integer c=128;
Integer d=128;
System.out.println(c==d);
System.out.println(c.equals(d));
}
static void Demo(){
/*1、获取对象包装器类,以Integer为例:
* 最简单的是使用new,可以传入一个本类的基本数据和""包含的本类基本数据
* 注意:如果""中包含的不是本类基本数据会抛出一个运行时异常
*/
Integer a=new Integer(3);
Integer b=new Integer("3");
//2、也可以使用静态方法valueOf()来获取对象包装类对象实例
// Integer c=Integer.valueOf("3");
// Integer d=Integer.valueOf("3", 10); //第二个参数指定进制
// Integer e=Integer.valueOf(3); //这是1.5版本后新增的
//3、当然也可以将包装类对象转换为基本类型,注意不仅可以是本类基本类型,还可以是其他基本类型(但不是所有的)
// int f=a.intValue();
// byte g=a.byteValue();
//4、基本类型封装成对象之后的比较
System.out.println(a==b); //比较地址
System.out.println(a.equals(b)); //比较是否相等
System.out.println(a.compareTo(b)); //比较大小(根据字典顺序)
}
private static void toStringDemo() {
//对象包装类的一个主要作用就是将基本数据类型和String类型互换
//1、基本类型转换为String类型
Integer i=new Integer(60);
//使用静态方法
System.out.println(Integer.toString(i));
System.out.println(Integer.toString(i, 16));
//
System.out.println(i.toString());
//Integer类还可以选择特定的进制进行转换,如2进制,8进制,16进制。是静态方法,内部调用toSting()
System.out.println(Integer.toBinaryString(i));
//2、String转换为基本类型
String s="60";
System.out.println(Integer.parseInt(s));
//！！！下面的进制是将字符串当做该进制的数进行解析,返回一个10进制的数
s="3c";
System.out.println(Integer.parseInt(s,16));
}
}
基本类型对象包装类
参考:自动装箱
http://openhome.cc/Gossip/Java/AutoBoxUnBox.html
http://www.cnblogs.com/danne823/archive/2011/04/22/2025332.html
2、集合类:
！！！集合框架图：
Collection接口和List接口的方法:
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator; public class CollectionInterface {
public static void main(String[] args){
Demo();
iteratorDemo();
listDemo();
ListIteratorDemo();
} public static void Demo() {
ArrayList a1=new ArrayList();
ArrayList a2=new ArrayList();
a1.add("asd1");
a1.add("asd2");
a2.add("asd2");
a2.add("asd3");
System.out.println("a1="+a1);
System.out.println("a2="+a2);
//注意:addAll()会将指定集合所有对象都添加,即使用重复的也会添加
a1.addAll(a2);
System.out.println("a1="+a1);
//注意:removeAll()会将指定集合所有对象都删除,！！！两者*有的也会删除
a1.removeAll(a2);
System.out.println("a1="+a1);
//retainAll()和removeAll()相反,会将指定集合所有对象都保存,而把其他全删除
} public static void iteratorDemo() {
ArrayList a1=new ArrayList();
a1.add("asd1");
a1.add("asd2");
a1.add("asd3");
a1.add("asd4");
/*迭代器是集合容器用来取元素的方法,不同集合有不同的取法,所以具体的迭代器依赖于具体容器,
* ！！！Java只提供一个接口,每一个容器都需要将其作为 内部类 实现用以获取元素即可
* 使用iterator()获取一个迭代器,并用该迭代器获取集合中对象,
* 迭代器Iterator接口有三个方法:
* 1、hasNext():检测是否有下一个元素,因为获取方法不检测是否超过集合容量,超过会报错
* 2、next():获取下一个元素
* 3、remove():删除元素
*/
// Iterator i=a1.iterator();
// while(i.hasNext()){
// System.out.println(i.next());
// }
// ！！！使用while循环的缺点是在循环遍历后,该迭代器已经不能去除任何值,但仍可以使用,浪费空间,可改为for循环
for(Iterator i=a1.iterator();i.hasNext();){
System.out.println(i.next());
}
} private static void listDemo() {
//List集合的特有方法:由于List集合中元素有角标,！！！所以特殊方法就是利用角标来进行增删改查
//注意 改 的方法在Collection中没有
ArrayList a=new ArrayList();
//普通添加和指定位置添加
a.add("asd2");
System.out.println("a="+a);
a.add(0,"asd3");
System.out.println("a="+a);
//修改指定位置元素,set()返回值是原来该位置的元素
System.out.println("被删除的元素是:"+a.set(0,"asd1"));
System.out.println("a="+a);
} private static void ListIteratorDemo() {
ArrayList a1=new ArrayList();
a1.add("asd1");
a1.add("asd2");
a1.add("asd3");
// Iterator i=a1.iterator();
// while(i.hasNext()){
// Object obj=i.next();
// if(obj=="asd3"){
// a1.add("asd5");
// }else{
// System.out.println(i.next());
// }
// }
/*在使用迭代器Iterator接口时,!!!不能同时进行增/删/改的操作,
* 会报ConcurrentModificationException异常。
* 可以使用子接口ListIterator接口代替,！！！由名字可以看出只在List集合中使用
* ListIterator还允许逆向遍历List,使用hasPrevious()
*/
ListIterator i=a1.listIterator();
while(i.hasNext()){
Object obj=i.next();
if(obj=="asd3"){
i.add("asd4");
}else{
System.out.println(i.next());
}
}
System.out.println("a1="+a1);
}
}
Collection练习
下面是List接口的常用子类:
public class Person implements Comparable<Person>{
private int age;
public Person(int age, String name) {
super();
this.age = age;
this.name = name;
}
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//这里的重写是为了HastSet练习使用
@Override
public int hashCode() {
return name.hashCode()+age;
}
@Override
public boolean equals(Object obj) {
Person p=(Person)obj;
return this.name.equals(p.name)&&(this.age==p.age);
}
//这里的 重写是为了TreeSet练习使用
@Override
public int compareTo(Person o) {
//注意适用泛型后不需要在进行类型强转
int count=0;
if(o instanceof Person){
Person p=(Person)o;
// if(this.age>p.age){
// return 1;
// }else if(this.age<p.age){
// return -1;
// }else{
// return this.name.compareTo(p.name);
// }
return count=this.age-p.age==0?this.name.compareTo(p.name):count;
}
return 0;
}
}
Person类
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import com.lll.cn.Person; public class ListSubClassDemo {
public static void main(String[] args){
VectorDemo();
LinkedListDemo();
LinkedListTest();
ArrayListDemo();
} public static void VectorDemo() {
//该类由于效率低下,和Enumeration一起不推荐使用
} public static void LinkedListDemo() {
/*LinkedList是链表结构,所以特殊方法是和第一个元素/最后一个元素相关
* 如在第一个/最后一个位置添加元素,删除元素,获取元素等
* ！！！注意有些方法仅仅获取,有些是移除并返回
* 注意:
*/
LinkedList<String> l=new LinkedList<String>();
l.add("asd2");
l.add("asd3");
l.addFirst("asd1");
System.out.println("最后一个元素是"+l.getLast());
while(!l.isEmpty()){
System.out.println(l.removeFirst());
}
System.out.println(l);
} public static void LinkedListTest() {
/*使用LinkedList模拟堆栈和队列两种数据结构
* 堆栈:先进后出First In Last Out -->FILO
* 队列:先进先出First In First Out -->FIFO
*/
StackDemo q=new StackDemo();
q.myAdd("asd9");
q.myAdd("asd2");
q.myAdd("asd3");
q.myAdd("asd4");
System.out.println(q.myRemove());
} private static void ArrayListDemo() {
//ArrayList集合是最常用的的集合,并且通常用于存储自定义对象
ArrayList<Person> a=new ArrayList<Person>();
a.add(new Person(11,"asd1"));
a.add(new Person(12,"asd2"));
a.add(new Person(13,"asd3"));
a.add(new Person(14,"asd4"));
/*！！！注意在使用集合存储数据时的易错点
* 1、所有自定义类型都会转换为Object类型,所以在使用时应该进行强制转换
* 2、在一个循环中使用next()时应该小心,因为每次next()都会将指针向下移动而不再指向刚才对象
* 下面就是错误示例
*/
for (Iterator<Person> i = a.iterator(); i.hasNext();) {
//System.out.println(i.next().getName()+i.next().getAge());
Person p=(Person) i.next();
System.out.println(p.getName()+":"+p.getAge()); }
}
}
class QueueDemo{
private LinkedList<Person> l=null;
QueueDemo(){
l=new LinkedList<Person>();
}
public void myAdd(Person obj){
l.add(obj);
}
public Object myRemove(){
return l.removeFirst();
}
}
class StackDemo{
private LinkedList<String> l=null;
StackDemo(){
l=new LinkedList<String>();
}
public void myAdd(String obj){
l.add(obj);
}
public Object myRemove(){
return l.removeLast();
}
}
ListSubClassDemo练习
迭代器接口(Iterator):用于获取容器中的元素,是枚举类(Enumeration)的改进版,增加了删除功能并简化了书写。枚举类是伴随着Vector类的出现而出现的,也伴随着该类的改进(使用ArrayList代替)而被改进(使用Iterator代替)
链表和数组:
LinkedList特有方法:
Set常用子类:
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.TreeSet; import com.lll.cn.Person; public class SetSubDemo {
public static void main(String[] args){
HashSetDemo();
HastSetTest();
TreeSetDemo();
} public static void HashSetDemo() {
/*HashSet的底层结构仍是数组,但是有所改进:
* 即存入数据时是根据哈希算法获取该数据的地址值,然后将其存入该地址
* 特点:
* 1、不允许存入相同元素,
* 2、如果计算出两个相同地址值,会将后者进行修改后存储
* 3、获取时计算地址值,如果该位置有元素且
* ！！！注意确定对象地址值的哈希算法就是对象内部的hashCode(),如果没有则使用继承自Object的
* 所以要使用HashSet来存储数据,并保证其中的值唯一,应该修改hashCode()和equals()
*
* ！！！在集合中对一个元素进行操作(例如remove,contains),首要的是判断在集合中是否有该对象,
* 通常依靠的是equals()和hashCode()。所以使用自定义对象时,应该对这两个方法进行重写
*/
} public static void HastSetTest() {
HashSet<Person> hs=new HashSet<Person>();
//如果自定义对象也要达到确保唯一性的要求,就要覆写hashCode()和equals(),原因见上
hs.add(new Person(11,"asd1"));
hs.add(new Person(12,"asd2"));
hs.add(new Person(13,"asd3"));
hs.add(new Person(14,"asd4"));
hs.add(new Person(11,"asd1"));
for (Iterator<Person> i = hs.iterator(); i.hasNext();) {
Person obj = (Person) i.next();
System.out.println(obj.getName()+":"+obj.getAge());
}
//HashSet还有一个子类LinkedHashSet,具有LinkedList和HashSet双重特性:即有序又唯一
LinkedHashSet<Person> lhs=new LinkedHashSet<Person>();
lhs.add(new Person(11,"asd1"));
lhs.add(new Person(12,"asd2"));
lhs.add(new Person(13,"asd3"));
lhs.add(new Person(14,"asd4"));
lhs.add(new Person(11,"asd1"));
for (Iterator<Person> i = lhs.iterator(); i.hasNext();) {
Person obj = (Person) i.next();
System.out.println(obj.getName()+":"+obj.getAge());
}
} public static void TreeSetDemo() {
/*TreeSet集合会对存入的对象进行比较然后进行存放,比较的过程可以用以下两种方式实现
* 1、使对象实现Comparable借口,重写compareTo(),称为自然排序方法
* 2、使集合具备排序功能,就是向TreeSet中传入一个实现了Comparator接口的类的对象实例
*/
TreeSet<Person> ts=new TreeSet<Person>();
ts.add(new Person(21,"asd1"));
ts.add(new Person(22,"asd2"));
ts.add(new Person(22,"asd3"));
ts.add(new Person(24,"asd4"));
for (Iterator<Person> i = ts.iterator(); i.hasNext();) {
Person p = (Person) i.next();
System.out.println(p.getName()+":"+p.getAge());
}
TreeSet<Person> ts2=new TreeSet<Person>(new ComparatorByName());
ts2.add(new Person(21,"asd1"));
ts2.add(new Person(22,"asd2"));
ts2.add(new Person(22,"asd3"));
ts2.add(new Person(24,"asd1"));
for (Iterator<Person> i = ts2.iterator(); i.hasNext();) {
Person p = (Person) i.next();
System.out.println(p.getName()+":"+p.getAge());
}
}
}
SetSubDemo练习
import java.util.Comparator; import com.lll.cn.Person; public class ComparatorByName implements Comparator<Person>
{
//这个类是外部类,用于集合中元素的比较
@Override
public int compare(Person p1, Person p2)
{
int comp=0; return (comp=p1.getName().compareTo(p2.getName()))!=0?comp:p1.getAge()-p2.getAge();
//return 1;
}
}
TreeSet比较使用的类
哈希如何判断元素相等:
二叉树:会用自然排序或自定义排序方法进行排序,取出时按排好的顺序从左到右取出。但是并不意味着必须是从小到大的顺序,因为如果左边第一个是最大的,就是从大到小取。当然也可以有序存取(即先存先取/后存后取)
集合总结:
1、选择集合容器的技巧
2、集合容器体系和数据结构区分