Java上路12-集合

       存储数据用数组，存储对象用集合。集合的长度可变，存储的对象类型可以不同。集合中这些存储对象的东东叫容器，都实现于接口Collection。集合中存储的都是对象的地址。

       Collection的子类都有add，remove，contains，clear，iterator方法。

import java.util.*;
 
class CollectionDemo
{
       public static void main(String[] args)
       {
              //创建一个集合容器，使用子类ArrayList
              ArrayList al=new ArrayList();
 
              //添加元素（对象）
              al.add("java 01");
              al.add("java 02");
              al.add("java03");
              al.add("java 04");
 
              //打印
              getColl("alsize:"+al.size());
              getColl("原al:"+al);
 
              //删除
              System.out.println("al删除\"java 02\" "+
              al.remove("java 02"));
              getColl("al:"+al);
 
              //是否包含
              System.out.println("al中包含\"java 03\" "+
              al.contains("java 03"));
 
              ArrayList alt=new ArrayList();
              alt.add("java 02");
              alt.add("java 03");
              alt.add("java 04");
              System.out.println("原alt:"+alt);
 
              //alt保留和al的交集
              alt.retainAll(al);
              getColl("保留和al的交集后，alt:"+alt);
 
              //alt删除和al的交集
              alt.removeAll(al);
              getColl("删除和al的交集后，alt:"+alt);
 
              //清空
              al.clear();
 
              //是否为空
              System.out.println("al.clear()之后al为空"+
              al.isEmpty());
 
              ArrayList arr=new ArrayList();
              arr.add("ArrayList01");
              arr.add("ArrayList02");
              arr.add("ArrayList03");
              arr.add("ArrayList04");
              arr.add("ArrayList05");
 
              //迭代，遍历
              for (Iterator ite=arr.iterator();ite.hasNext(); )
              {
                     getColl("元素："+ite.next());
              }
       }
 
       public static void getColl(Object obj)
       {
              System.out.println(obj);
       }
}   

 

一. List：

元素有索引，因此可以重复。特有方法：

增：       add(int index, Eelement)

              addAll(int index, Collection)

删：       remove(int index)

改：       set(int index, Eelement)

查：       get(int index)

              subList(int fromIndex, inttoIndex)

              listIterator(int index)

       代码示例：

import java.util.*;
 
class ListDemo
{
       public static void getColl(Object obj)
       {
              System.out.println(obj);
       }
 
       public static void main(String[] args)
       {
              //List的子类ArrayList
              ArrayList alt=new ArrayList();
              alt.add("ArrayList1");
              alt.add("ArrayList2");
              alt.add("ArrayList3");
              alt.add("ArrayList4");
              getColl("原    集      合："+alt);
 
              //指定索引插入
              alt.add(1,"Java  list");
              getColl("索引1插入，新集合："+alt);
 
              //指定位置删除
              alt.remove(1);
              getColl("索引1删除，新集合："+alt);
 
              //指定索引修改
              alt.set(2,"Javaworld");
              getColl("索引2修改，新集合："+alt);
 
              //查询指定索引的元素
              getColl("索引2元素是："+
                     alt.get(2));
 
              //查询所有元素
              for(int x=0; x<alt.size(); x++)
              {
                     getColl("集合alt("+x+"):"+alt.get(x));
              }
 
              //迭代查询
              for(Iterator ite=alt.iterator(); ite.hasNext(); )
              {
                     getColl("迭代，next:"+ite.next());
              }
 
              ListIterator ltr=alt.listIterator();
              while(ltr.hasNext())
              {
                     Object obj=ltr.next();
                     if(obj.equals("ArrayList2"))
                     {
                            ltr.set("Vigiles");
                            ltr.add("Hello");
                     }
              }
              getColl("迭代while添加："+alt);
 
              //迭代修改，仅用于List对象。不能使用集合和迭代器同时操作容器
              for(ListIterator lt=alt.listIterator(); lt.hasNext(); )
              {
                     Object obj=lt.next();
                     if(obj.equals("ArrayList4"))
                     {
                            lt.add("Friend");
                            //lt.set("Vigiles");
                     }
              }
              getColl("迭代器for添加："+alt);
       }
}  

  

 

       ListIterator还有个hasPrevious属性，以及previous()方法，可以在迭代正序后倒序访问元素。代码片段：

              ListIterator lit=alt.listIterator();

 
              //正序迭代
              while(lit.hasNext())
              {
                     getColl("next:"+lit.next());
              }
 
              //倒序迭代
              while(lit.hasPrevious())
              {
                     getColl("previous:"+lit.previous());
              }   

 

       List最重要的三个子类

ArrayList：数组结构存储。查询很快；增删稍慢，元素越多越明显。多线程不同步。

LinkedList：链表（链条）数据结构。元素前后关联，有助于按顺序访问元素。增删很快，查询稍慢。

Vector：类似数组的数据结构。多线程同步。基本被ArrayList替代。

 

二. LinkedList：

         链表集合。此实现不是同步的。如果多个线程同时访问一个链接列表，而其中至少一个线程从结构上修改了该列表，则它必须保持外部同步。    

import java.util.*;
 
class LinkedListDemo
{
       public static void main(String[] args)
       {
              LinkedList ll=new LinkedList();
 
              ll.addFirst("LinkedList1");
              ll.addFirst("LinkedList2");
              ll.addFirst("LinkedList3");
              ll.addFirst("LinkedList4");
              getColl("\n头部addFirst加入："+ll);
 
              ll.addLast("LinkedList5");
              ll.addLast("LinkedList6");
              getColl("尾部addLast加入："+ll);
 
              getColl("头部offerFirst加入："+
                     ll.offerFirst("HelloJava")+"\n新集合："+ll);
 
              getColl("头部get查询："+
                     ll.getFirst());  //如果集合为空，返回NoSuchElementException异常
 
              getColl("尾部get查询："+
                     ll.getLast());  //如果集合为空，返回NoSuchElementException异常
 
              getColl("头部peek查询："+
                     ll.peekFirst());       //如果集合为空，返回null
 
              getColl("头部remove删除："+
                     ll.removeFirst()+   //返回删除的元素。如果集合中没有元素会出现NoSuchElementException异常
                     "头部删除后集合长度："+ll.size());
 
              getColl("尾部remove删除："+
                     ll.removeLast()+   //返回删除的元素。如果集合中没有元素会出现NoSuchElementException异常
                     "尾部删除后集合长度："+ll.size());
 
              getColl("头部poll删除："+
                     ll.pollFirst());  //如果集合为空，返回null
       }
 
       public static void getColl(Object obj)
       {
              System.out.println(obj);
       }
}  

  

 

三. Set：

       元素无序，不可以重复。线程非同步。Set集合的功能和Collection一致。子类HashSet、TreeSet。HashSet通过hashCode方法和equals方法保证元素的唯一性。如果hashCede值相同才回调用equals方法。ArrayList只依赖equals方法判断元素。

import java.util.*;
 
class Person
{
       private String name;
       private int age;
 
       Person(String name, int age)
       {
              this.name=name;
              this.age=age;
       }
 
       //底层自动调用
       public int hashCode()
       {
              System.out.println(this.name+"计算hash code");
              return name.hashCode()+age;
       }
 
       public String getName()
       {
              return name;
       }
 
       public int getAge()
       {
              return age;
       }
 
       //底层自动调用
       public boolean equals(Object obj)
       {
              if (!(obj instanceof Person))
              {
                     //如果调用的对象不是Person的实例，返回false
                     return false;
              }
 
              //如果调用的是Person的实例
              Person p=(Person)obj;
 
              System.out.println(this.name+"..同名比较.."+p.name);
 
              //根据name和age两个方面与之前存储的比较。有一个方面不同即返回false
              return this.name.equals(p.name)&&this.age==p.age;
       }
}
 
class HashSetDemo
{
       public static void main(String[] args)
       {
              HashSet hs=new HashSet();
 
              hs.add(newPerson("a1",23));
              hs.add(newPerson("a2",23));
              hs.add(newPerson("a3",23));
              hs.add(newPerson("a4",23));
              hs.add(newPerson("a5",23));
              hs.add(newPerson("a3",23));
              hs.add(newPerson("a4",23));
             
              Iterator it = hs.iterator();
 
              while (it.hasNext())
              {
                     Person p =(Person)it.next();
                     show(p.getName()+"---"+p.getAge());
              }
       }
 
       public static void show(Object obj)
       {
              System.out.println(obj);
       }
}  

 

四. TreeSet：

       可以自动为元素按ASCII码排序。底层数据结构是二叉树，自动调用compareTo方法比较元素顺序。如果返回0即相同，-1为小保存在前，1为大保存在后。

       第一种方式：元素实现Comparable接口，覆盖compareTo方法：

import java.util.*;
 
class Student implements Comparable     //强制让Student具备比较性
{
       private String name;
       private int age;
 
       Student(String name, int age)
       {
              this.name=name;
              this.age=age;
       }
 
       //实现Comparable的类底层默认调用此方法
       public int compareTo(Object obj)
       {
              if (!(obj instanceof Student))
              {
                     throw new RuntimeException("不是Student对象");
              }
 
              Student s=(Student)obj;
              if (this.age>s.age)
              {
                     return 1;
              }
              if (this.age==s.age)
              {
                     return this.name.compareTo(s.name);
              }
              return -1;
       }
 
       public String getName()
       {
              return name;
       }
 
       public int getAge()
       {
              return age;
       }
}
 
class TreeSetDemo
{
       public static void main(String[] args)
       {
              TreeSet ts=new TreeSet();
 
              ts.add(new Student("张三",12));
              ts.add(new Student("李四",34));
              ts.add(new Student("王五",34));
              ts.add(new Student("赵六",22));
 
              Iterator it=ts.iterator();
 
              while (it.hasNext())
              {
                     Student s =(Student)it.next();
                     System.out.println(s.getName()+"..."+s.getAge());
              }
       }
}   

 

       第二种方式：当元素不具备比较性，或所具备的比较性不是需要的。此时需要集合具备比较性。此方式为底层首选。

import java.util.*;
 
class Student
{
       private String name;
       private int age;
 
       Student(String name, int age)
       {
              this.name=name;
              this.age=age;
       }
 
       public String getName()
       {
              return name;
       }
 
       public int getAge()
       {
              return age;
       }
}
 
class TreeSetDemo
{
       public static void main(String[] args)
       {
              //使用比较器使元素具有比较性
              TreeSet ts=new TreeSet(newMyComparator());
 
              ts.add(new Student("张三",12));
              ts.add(new Student("李四",34));
              ts.add(new Student("王五",34));
              ts.add(new Student("赵六",22));
              ts.add(new Student("王五",30));
              ts.add(new Student("赵六",23));
 
              Iterator it=ts.iterator();
 
              while (it.hasNext())
              {
                     Student s =(Student)it.next();
                     System.out.println(s.getName()+"..."+s.getAge());
              }
       }
}
 
class MyComparator implements Comparator //比较器
{
       public int compare(Object o1, Object o2)
       {
              Student s1=(Student)o1;
              Student s2=(Student)o2;
 
              int num=s1.getName().compareTo(s2.getName());
              if (num==0)
              {
                     return newInteger(s1.getAge()).compareTo(new Integer(s2.getAge()));
              }
              return num;
       }
}