JAVA集合

集合   
            数目不固定的一组数据，位于java.util包中。
Java集合只能存放对象的引用。
            Java中集合主要分为三种类型：
            . Set : 无序，并且放进集合中的对象不能重复。
            . List: 有序(放入的先后的次序), 放进集合中的对象可以重复。
            . Map : 集合中的每一个元素包含一对键对象和值对象，集合中没有重复的键对象，值对象可以重复。（Key - Value）


            1. Collection和Iterator接口
      Set和List接口继承了Collection接口
               在Collection接口中声明了适用于Set和List的通用方法：
               boolean add(Object o)          : 向集合中加入一个对象的引用；
               void clear()                   : 删除集合中的所有对象引用，即不再持有这些对象的引用；
               boolean contains(Object o)     : 判断在集合中是否持有特定对象的引用；
               boolean isEmpty()              : 判断集合是否为空；
               Iterator iterator()            : 返回一个Iterator对象，可用它来遍历集合中的元素；
               boolean remove(Object o)       : 从集合中删除一个对象的引用；
               int size()                     : 返回集合中元素的数目；
               Object[] toArray()            : 返回一个数组，该数组包含集合中的所有元素；

      Iterator接口中的定义的方法可以帮我们去遍历集合中的元素。
               Iterator接口隐藏底层集合的数据结构，向客户程序提供了遍历各种类型的集合的统一方法。Iterator接口中声明方法：


               hasNext()                      : 判断集合中的元素是否遍历完毕，如没有，就返回true;
               next()                         : 返回下一个元素；
               //remove()                       : 从集合中删除上一个由next()方法返回的元素；
------------------------------------------------------------------------------------------
               集合添加对象遍历对象例子：
               import java.util.*;
               public class Test {
                      public static void print(Collection c) {
                             Iterator it = c.iterator();
                             while(it.hasNext()) {
                                    Object element = it.next();
                                    System.out.println(element);
                             }
                      }


                      public static void main(String args[]) {
                             Set set = new HashSet();
                             set.add("SETA");
                             set.add("SETB");
                             set.add("SETC");
print(set);
 
                             List list = new ArrayList();
                             list.add("LISTA");
                             list.add("LISTB");
                             list.add("LISTC");
                             print(list);


                             Map map = new HashMap();
                             map.put("1","MAPA");
                             map.put("2","MAPB");
                             print(map.entrySet());
                     }
               }
------------------------------------------------------------------------------------------


            2. Set
               最简单的一种集合，集合中的对象无序、不能重复。主要实现类包括：         
               . HashSet      : 按照哈希算法来存取集合中的对象，存取速度比较快；
               . LinkedHashSet: HashSet子类，不仅实现Hash算法，还实现链表数据结构，链表数据结构能提高插入和删除元素的性能；
               . TreeSet      : 实现SortedSet接口，具有排序功能；


               一般用法：
               Set集合中存放的是对象的引用，并且没有重复对象。


               Set set = new HashSet();
               String s1 = new String("hello");
               String s2 = s1;
               String s3 = new String("world");
               set.add(s1);
               set.add(s2);
               set.add(s3);
               System.out.println(set.size());


  //输出2
  
  1) HashSet
               当一个新的对象加入到Set集合中时，Set的add方法会遍历既存对象，先调用对象的hashCode()方法比较,如果是true再调用equals()方法按照内存地址比较对象是否相等,如果还是true则表明引用的是同一个对象，证明两对象相同。
               当添加用户自定义的对象时，为了正确识别重复对象，需要重写这两个方法。
------------------------------------------------------------------------------------------
  重写hashCode()和equals()方法的步骤：
                  public class Customer {
                         private String name;
                         private int age;


                         public Customer(String name, int age) {
                                this.name = name;
                                this.age = age;
                         }
                         
                         public String getName() {
                                return name;
                         }


                         public int getAge() {
                                return age;
                         }


public int hashCode() {
                         return this.age;
                  }
                         public boolean equals(Object o) {
                                if(this==o) return true;                          
                                if(!(o instanceof Customer)) return false;
                                Customer other = (Customer)o;


                                if(this.name.equals(other.getName()) && this.age==other.getAge())
                                      return true;
                                else 
                                      return false;


                         }
                  }
------------------------------------------------------------------------------------------


               2) TreeSet
                  TreeSet实现了SortedSet接口，能够对集合中的对象进行排序。当TreeSet向集合中加入一个对象时，会把它插入到有序的对象序列中。
 TreeSet支持两种排序方式：自然排序和客户化排序。默认情况下TreeSet采用的是自然排序方式：


                  a. 自然排序


                     在JDK类库中， 有一部分类实现了Comparable接口，如Integer、Double和String等。Comparable接口有一个
                     compareTo(Object o)方法，它返回整数类型。对于x.comapreTo(y), 如


                     返回0,      表明   x和y相等
                     返回值大于0, 表明   x>y  
                     返回值小于0, 表明   x<y


           从小到大排
即:想表示出x比y大,让x.comapreTo(y)返回一个大于0的数字即可

*其中，x是新对象，y是老对象。           
                     TreeSet调用对象的compareTo()方法比较集合中对象的大小，然后进行【升序】排序，这种排序方式称为自然排序。
                    
                     JDK类库中实现了Comparable接口的一些类的排序方式： 


                     Byte, Short, Integer, Long, Double, Float     :         按数字大小排序；
                     Character                                     :         按字符的Unicode值的数字大小排序；
                     String                                        :         按字符串中字符的Unicode值排序； 
                     *使用自然排序，TreeSet中只能加入相同类型对象，且这些对象必须实现了Comparable接口。否则会抛出ClassCastException异常。


                     当修改了对象的属性后， TreeSet不会重新排序。最适合TreeSet排序的是不可变类(它们的对象的属性不能修改)。
------------------------------------------------------------------------------------------
                     自然排序例子，实现Comparable接口，重写compareTo()方法：
import java.util.*;


                     public class Test implements Comparable{
int x;
public Test(int x) {
this.x = x;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
@Override
public int compareTo(Object o) {
//o是老元素，返回值大于0，表示新元素this比老元素o大，按从小到大排，把新元素放在后面
Test z=(Test) o;
return this.getX()-z.getX();
}


public static void main(String args[]) {
Set set = new TreeSet();
Test a = new Test(1);
Test b = new Test(2);
Test c = new Test(3);
set.add(b);
set.add(a);
set.add(c);
Iterator i=set.iterator();
while(i.hasNext()){
Test z=(Test) i.next();
System.out.println(z.getX());
}
}
}
//输出1 23
------------------------------------------------------------------------------------------




                  b. 客户化排序                


                     除了自然排序外， TreeSet还支持客户化排序。java.util.Comparator接口提供了具体的排序方法， 它有一个
                     compare(Object x, Object y)方法，用于比较两个对象的大小， 当compare(x,y)：


                     返回0,       表明   x和y相等
                     返回值大于0, 表明   x>y
                     返回值小于0, 表明   x<y


*其中，x是新对象，y是老对象。
----------------------------------------------------------------------------------------- 
客户化排序例子，实现Comparator接口，重写compare()方法，同上。
注意new Set时传入有compare方法的new class():
package t;


import java.util.*;


public class Test implements Comparator{
int x;
public Test(){
//空构造方法，主函数需要，也可使用传参构造方法传入任意int，或单独创建方法类
}
public Test(int x) {
this.x = x;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
@Override
public int compare(Object o1, Object o2) {
//o1是新对象，o2是老对象，大于0则说明o1大，放o2后面
Test t1=(Test) o1;
Test t2=(Test) o2;
return t2.getX()-t1.getX();
}


public static void main(String args[]) {
//创建set时需要new含有compare方法的类
Set set = new TreeSet(new Test());
Test a = new Test(1);
Test b = new Test(2);
Test c = new Test(3);
set.add(b);
set.add(a);
set.add(c);
Iterator i=set.iterator();
while(i.hasNext()){
Test z=(Test) i.next();
System.out.println(z.getX());
}
}
}
//输出 3 2 1
------------------------------------------------------------------------------------------




            3. List
 
               主要特征是其元素以线性方式存储，集合中允许存放重复对象。主要实现类包括：
               . ArrayList: 代表长度可变的数组。允许对元素进行快速的随机访问，但是向ArrayList中插入与删除元素的速度较慢；
               . LinkedList: 在实现中采用链表结构。对顺序访问进行了优化，向List中插入和删除元素的速度较快，随机访问速度则相对较慢。
      Vector:   是线程安全的集合
               遍历方式：
               a. list.get(i);    //通过索引检索对象；
  *可用list.size()获取长度，i从0开始遍历，list.get(i)获取值；
               b. Iterator i = list.iterator();
                  i.next();      //i.next()即为对应值
               
  *删除方式：
  List a=new ArrayList();
      a.add(1);
      a.add(3);
      a.add(2);
      a.add(1);
      a.add("e");
      a.remove("e");
  a.remove("e");
      System.out.println(a);
  此时其中一个"e"被删除；输入a.remove(3)时，第四个元素被删除（下标从0开始）；
  输入1时第二个被删除；可见下标优先。


            4. Map
      HashMap  是线程不安全的集合。
      HashTable是线程安全的集合。
      TreeMap可以进行排序(对key进行排序) 
               Map是一种把键对象和值对象进行映射的集合，它的每一个元素都包含一对键对象和值对象。向Map集合中加入元素时，必须提供一对键对象和值对象，从Map集合中检索元素时，只要给出键对象，就会返回对应的值对象。


               map.put("2", "Tuesday");
               map.put("3", "Wednsday");
               map.put("4", "Thursday");


               String day = map.get("2");    //day的值为"Tuesday"
  
  *覆盖：
               Map集合中的键对象不允许重复，如以相同的键对象加入多个值对象，第一次加入的值对象将被覆盖。
  
               对于值对象则没有唯一性的要求，可以将任意多个键对象映射到同一个值对象上。


               map.put("1", "Mon");
               map.put("1", "Monday");      //"1"此时对应"Monday"
               map.put("one", "Monday");    //"one"此时对应"Monday"
               map.remove("1");//通过key删除元素
  map.clear();//清空集合
               Map有两种比较常见的实现：


               1) HashMap
                  按哈希算法来存取键对象，有很好的存取性能，为了保证HashMap能正常工作，和HashSet一样，要求当两个键对象通过equals()方法比较为true时，这两个键对象的hashCode()方法返回的哈希码也一样。


               2) TreeMap
                  实现了SortedMap接口，能对键对象进行排序。和TreeSet一样，TreeMap也支持自然排序和客户化排序两种方式。(排序按照的是KEY值)
 
 常用方法：
 Collection c = map.values();//获取map的value集合
         Iterator i = c.iterator();  //使用iterator遍历c
         System.out.println(i.next());//格式正确的话输出第一个值
 
 Set s = map.keySet();       //获取map的key集合，可用set接收
         Iterator i = s.iterator();
         System.out.println(i.next());//同上
 System.out.println(map.get(i.next()));//输出key对应的value。注意，上一步执行i.next()后，i指向了下一个对象。
 
 删除方式：map.remove(key);
 参数只能为key值
------------------------------------------------------------------------------------------
 遍历map的三种方式，iterator、entrySet、增强for循环：
 //
a.通过iterator()访问keySet()生成的Set集合:
                  Map map = new TreeMap();
                  map.put("1", "Monday");
                  map.put("3", "Wednsday");
                  map.put("4", "Thursday");
                  map.put("2", "Tuesday");


                  Set keys = map.keySet();
                  Iterator it = keys.iterator();
                  while(it.hasNext()) {
                        String key = (String)it.next();
                        String value= (String)map.get(key);
                        System.out.println(key + " " + value);
                  }


                  打印输出：


                  1 Monday
                  2 Tuesday
                  3 Wednsday
                  4 Thursday
b1.通过entrySet()使用iterator遍历key和value：
        Map map=new HashMap();
map.put("a", 1);
map.put(2, "2");
map.put('c', 3);
Iterator i=map.entrySet().iterator();
while(i.hasNext()){
 //需要转换为Entry
 Map.Entry entry=(Entry) i.next();
 System.out.println(entry.getKey()+" "+entry.getValue());
}
输出：2 2
              c 3
              a 1
 
b2.通过entrySet()使用增强for循环遍历（创建Map需要泛型）：
public static void main(String args[]) {
//创建Map时需要泛型，否则报错cannot convert from element type Object to Map.Entry
Map<String,Integer> map=new HashMap();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);
for(Entry e:map.entrySet()){
System.out.print(e.getKey()+" ");
            System.out.println(e.getValue());
}

输出：b 2
              c 3
              a 1
//增强for循环中输入System.out.println(e);则输出b=2 c=3 a=1


c1.使用增强for循环直接遍历Key或value:
   Map map=new HashMap();
map.put("a", 1);
map.put(2, "2");
map.put('c', 3);
for(Object key:map.keySet()){
            System.out.print(key+" ");
}
        System.out.println("\n------------");
for(Object value:map.values()){
            System.out.print(value+" ");
} 
输出：2 c a 
              ------------
              2 3 1 
c2.使用增强for循环直接遍历Key，通过get(key)得到对应value：
        Map map=new HashMap();
map.put("a", 1);
map.put(2, "2");
map.put('c', 3);
for(Object key:map.keySet()){
Object value=map.get(key);
            System.out.println(key+" "+value);
}
//输出：2 2
                c 3
                a 1
        //键值类型可不同 
 
------------------------------------------------------------------------------------------