黑马程序员-集合

集合

Collection
                 |--List:元素是有序的，元素可以重复。因为该集合体系有索引。
                                |--ArrayList:底层的数据结构使用的是数组结构。特点：查询熟读快，但是增删稍慢。线程不同步。
                                |--LinkedList:底层使用的是链表数据结构。特点：增删速度快，查询稍慢。
                                |--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。
                 |--Set:元素是无需（存入和取出的顺序不一定一致），元素不可以重复。
                                |--HashSet:底层数据结构是哈希表。
                                                HashSet是如何保证元素唯一性的呢？
                                                是通过元素的两个方法，HashCode和equals来完成。
                                                如果元素的HashCode值相同，才会判断equals是否为true
                                                如果元素的HashCode值不同，不会调用equals

                                               注意，对于判断元素是否存在，以及删除等操作，以来的方法是元素的Hashcode和equals方法。
                                |--TreeSet:可以对set集合中德元素进行排序。
                                                 底层数据结构是二叉树。保证元素唯一性的依据；comaparTo方法

TreeSet排序

 （1）第一种方式：让元素自身具备比较性。
       元素需要事先Comparable接口，覆盖compareTo方法。
        TreeSet排序的第二种方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时，就有比较方式。
    当元素自身不具备比较性，或者具备的比较性不是所需要的。这
    时需要让容器自身具备比较性。定义了比较起，将比较起对象作
    为参数传递给TreeSet构造函数里.
   
        两种方式都存在时已比较起为主
    定义一个类，实现Comparator接口，覆盖compare方法。

Collection：
import java.util.*;
ArrayList a=new ArrayList();
1）添加
      a.add("java");
     （1）add方法的参数类型是Object。以便于接受任意类型对象。
     （2）集合中存储的都是对象的引用（地址）

2）获取个数。集合长度
      a.size();
3）删除元素
      a.remove("java");
      a.clear;          //清空集合
4）判断元素
      a.contains("java");
      a.isEmpty();
5）交集
      a1.retainAll(a2); al中指保留和a12中相同的元素
      a1.removeAll(a2): a1中指保留和a12不同的元素
6）迭代器
      Iterator it=a.iterator();获取迭代器，用于取出集合中德元素
      while(it.hasNext())       //判断有没有元素
      sop(it.next());      //现实下一个元素
什么是迭代器呢？
其实就是集合的取出元素的方式
在迭代时循环中next调用一次，就要HasNext判断一次。

就把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内容的元素。
那么取出方式就被定义成了内部类。
而每一个容器的数据结构不同，所以取出的动作细节也不一样。但是都有共性内容，判断和取出，那么可以将携共性抽取。
那么这些内部类都符合一个规则。该规则是Iterator
如何获取集合的取出对象呢？
通过一个对外提供的方法。iterator();

List:
 特有方法。凡是可以操作角标的方法都是该体系特有的方法。
1）增
      add(index,element)
      addAll(index,Collection)
2）删
      remove(index);
3）改
      set(index,element);
4）查
      get(index)
      subList(from,to)     //前面的包含，后面的不包含
      listIterator();
      indexOf("java02")

List集合特有的迭代器。ListIterator是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生ConcurrentModificationException异常。

所以，在迭代其实，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作，如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator.
该接口只能通过List集合的listIterator方法获取。
 
import java.until.*;
ArrayList al=new ArrayList();
a1.add("java01")
a1.add("java02")
a1.add(1,"java09")            //结论:[java01,java09,java02,java03]
a1.remove(2);     //结论:[java01,java09,java03]
a1.set(2,"java007")     //结论:[java01,java09,java007]
a1.get(1)     //结论:java09
for(int x=0;x<a1.size();x++){
System.out.println(al.get(x));
}
a1.indexOf("java02")
a1.subList(1,3);   

//在迭代过程中，准备添加或删除元素
ListIterator li=al.listIterator();
while(it.hasNext()){
Object obj=li.next();
if(obj.equals("java02"))
 it.add("java009")
}  

        
Vector
枚举就是vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的。
因为枚举的名称以及方法的名称都过长。所以被迭代器取代了，枚举郁郁而终了。

Vector v=new Vector();
Enumeration en=v.elements();
en.hasMoreElements()  en.nextElement()

LinkedList
特有方法：
addFirst();
addLast();

getFirst();
getLast();
获取元素，但不删除元素，会出现NoSuchElementException

removeFirst();
removeLast();
获取元素，但删除元素
如果集合中没有元素，会出现NoSuchElementException

在JDK1.6出现了替代方法。
offerFist();
offerLast();

peekFirst();
peekLast();
获取元素，但不删除元素，会返回Null

pollFirst();
pollLast();
获取元素，但删除元素
如果集合中没有元素，会返回Null

堆栈：先进后出 如同一个杯子
队列：先进先出 FIFO 如同一个水管

List集合判断元素是否相同，依据是元素的equals方法

public boolean equasl(Object obj){
if(!(obj instanceof Person))
    return false;
Person p=(Person)obj;
return this.name.equals(p.name)&&this.age==p.age
}

SET
set集合的功能跟connection一样。

Hashset
public int hashCode(){
retrun name.hashCode()
}

TreeSet

class Student implements Comparable
public int compareTo(Object obj){
 if(!(obj instanceof Student))
  throw new RuntimeException("不是学生对象")
  Student s=(Student)obj;
 if(this.age>s.age)
  return 1;
 if(this.age==s.age)
  return this.name.compareTo(s.name);
e return -1;
}

主要条件相同的话，在判断次要条件。

TreeSet ts=new TreeSet(new MyCompare())
class MyCompare implements Comparator
{
public int compareTo(Object ob1,Object ob2){
Student s1=(Student)ob1;
Student s2=(Student)ob2;

if(s1.getName().compareTo(s2.getName())==0){
return s1.getAge() >s2.getAge())
 return 1;
if(s1.getAge()==s2.getAge())
 return 0;
return -1
new Integer(s1.getAge()).compare(new Integer(s2.getAge));

}
return s1.getName().compareTo(s2.getName()
}

JDK1.5版本以后出现了新特性。用于解决安全问题，是一个安全机制。
泛型
泛型格式好处：
1）将运行是其出现问题ClassCastException，转移到了编译时期，方便与程序员解决问题。让运行时期减少了，安全。
 例：ArrayList<String> al=new ArrayList<String>();
     Iterator<String> it=al.iterator();
2）避免了强制转换麻烦。

泛型格式：通过〈〉来定义要操作的引用数据类型。
在使用Java提供的对象时，什么时候写泛型呢？
通常在集合框架中很常见，只要见到〈〉就要定义泛型。
其实〈〉就是用来接受类型的。

当使用集合时，将集合中要存储的数据类型作为参数传递到〈〉中即可。
class LenComparator implements Comparator<String>{
public int compara(String o1,String o2)
}

 

什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展。现在定义泛型来完成扩展。

泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型的就已经固定了。
为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。

public <T> void show(T t){

}

特殊之处：
静态方法不可以访问类上定义的泛型，如果静态方法操作的引用数据就类型不确定，可以将泛型定义在方法上。
public static <T> void show(T t){

}
public static <T> void printcoll(ArrayList<T> al)==public static void printcoll(ArrayList<?> al)

<?>:通配符。也可以理解为占位符。
泛型的限定：
？extend E：可以接受E类型或者E的子类型。上限。
？super E：可以接受E类型或者E的父类型。下线。
public static  void printcoll(ArrayList<? extend Person〉 al)  //只能父类和子类能用
public static  void printcoll(ArrayList<Person〉 al)  //只能父类和子类能用

Collections.max(list,new StrLenComparator())

 集合Map
该集合存储键值对，一对一对往里存，而且要保证键的唯一性。
1）添加
      put(K key,V value)
      putAll(Map<? extends K,? extends V> m)
2）删除
      clear();
      remove(Object key)
3）判断
      containValue(Object value)
      containsKey(Object key)
      isEmpty()
4）获取
      get(Object key)
      size()
      values()   //获取Map集合中所有的值
      entrySet()
      keySet()   //所有的key放到Set里，用Set里的迭代器来取值，那时用get(Object key)
Map集合的两种取出方式：
 1）keySet():将map中所有的键存入到set集合。因为set具备迭代器。所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。
 Set<String> keySet=map.keySet();   //先获取map集合的所有键的set集合，keySet();
 Iterator<String> it=keySet.iterator();  //有了Set集合。就可以获取其迭代器。
 while(it.hasNext())
 {
 String key=it.next();
 String value=map.get(key);    //有了键可以通过Map集合的get方式获取器对应的值
 System.out.pritnln(key+value);
 }
 2）Set<Map.Entry<k,v>>entrySet():将Map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry
 Set<Map.Entry<String,String>> entrySet=map.entrySet(); 
 Iterator<Map.Entry<String,String>> it=entrySet.iterator();
 while(it.hasNext())
 {
  Map.Entry<String,String> me=it.next();
  String key=me.getKey();
  String value=me.getValue();   
  System.out.pritnln(key+value);
 }
 Map.Entry:其实Entry也是一个接口，它是Map接口中的一个内部接口。

Map
      |--Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0 效率低（和Set很像，骑士大家，set底层就是使用了Map集合。）
      |--HashMap：底层是哈希表数据结构，允许使用null键null值。该集合是不同步的。jdk1.2效率高
      |--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

Map<String,String> map=new HashMap<String,String>();
Collection<String> coll=map.values();

添加元素，如果出现添加是，相同的键，那么后添加的值会覆盖原有键对应值。

TreeMap<Student,String> tm=new TreeMap<Student,String>();
Set<Map.Entry<String,String>> entrySet=map.entrySet(); 

 

Collections 里面都是静态方法

（1）排序：

        void shuffle(List<?> list);//使用默认随机源对list集合中的元素进行随机排序

        void sort(Lsit<T> list);//根据自然顺序对list集合中的元素进行排序

        voidsort(List<T> lsit,Comparator<? super T> c);//根据指定比较器c的排序方式对list集合进行排序

（2）反转

        reverse(List<?> list);//反转list集合中元素的顺序

        Comparator reverseOrder();//返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序

        ComparatorreverseOrder(Comparator<T> cmp);//返回一个比较器，强行逆转了指定比较器的顺序

 

 

Collections和Collection的区别

        Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。

        它有两个常用的子接口：

                List：对元素都有定义索引。有序的。可以重复元素。        

                Set：不可以重复元素。无序

        Collections是集合框架中的一个工具类。该类中的方法都是静态的。提供的方法中有可以对list集合进行排序，二分查找等方法

       通常常用的集合都是线程不安全的。因为要提高效率。如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

 

int index=collections.binarySearch()   //排序之后在使用
数组变集合
Arrays:用于操作数组的工具类。里面都是静态方法。
asList;将数组变成List集合。

Q：把数组变成list集合有什么好处？
A：可以使用集合的思想和方法来操作数组中的元素。
注意：将数组变成集合，不可以使用集合的增删方法。
因为数组的长度是固定的。
get contains indexOf subList能用
如果你增删，那么会发生unsupportedOperationException

List<String> list=Arrays.asList(arr);  //String[] arr={"be",eg"","sa"}
List<int[]> li=Arrays.asList(nums);   //int[] nums={2,4,5}

如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

List<Integer> list=Arrays.asList(nums);  //Integer[] nums={2,4,5}
集合变数组
collection接口中的toArray方法。

Q：制定类型的数组到底要定义多长呢？
A：当制定类型的数组长度小于了集合的size，那么该方法内不会创建一个新的数组。长度为集合的size。
当制定类型的数组长度大于了集合的size，就不会新创建数组。而是使用传递进来的数组。
所以创建一个刚刚好的数组最优。

String[] arr=al.toArray(new String[al.size()]);

Q：为什么要将集合变数组？
为了限定对元素的操作。 不需要进行增删的。

高级for循环
格式：
for(数据类型 变量名：被变量的集合（collection）或者数组){
}

ArrayList<String> al=new ArrayList<String>();
for(String s:al)
{
s="kk";
}
注意：对集合进行遍历。只能获取元素。但是不能对集合进行操作。
迭代器除了遍历，还可以进行remove集合中元素的动作。
如果使用listIterator,还可以在遍历过程中进行增删改查的动作。

Q：传统for和高级for有什么区别呢？
A：高级for有一个局限性。必须有被遍历的目标。
建议在遍历数组的时候，还是希望使用传统for.因为传统for可以定义角标。