jse-集合框架

1.基本说明
Collection中有List Set接口
Map接口独立于Collection
Set 无序不可重复    HashSet TreeSet
List 有序可重复     ArrayList LinkedList Vector
Map 不能有相同的key HashMap HashTable TreeMap
HashMap和HashTabled的区别：1.在HashMap中key和value允许为null，而HashTable不允许
 2.HashMap线程不同步，HashTable线程同步
 3.HashMap具备快速死亡的特性


对于所有以hash表为数据结构的类中，判断两个实体类型是否相同是按照先判断Hashcode（）
返回的值是否相等，若相等再判断equals（）方法


数组用于存放基本数据类型
集合用于存放对象，当然你也可以将基本数据类型进行封装传到集合中
对于数组提供了Arrays的工具类
对于集合提供了Collections的工具类




2.List
在List下有三个实现类
 ArrayList    底层是数组结构，查询快，增删慢  默认长度10，按50%递增
 LinkedList   底层是链表结构，查询慢，增删快 
 Vector（向量）底层据说也是数组结构，线程同步 100%递增
因为Vector是线程同步的，影响执行效率，已经过时，功能皆被ArrayList替代
而且对于集合，Collections类已经为集合提供了线程同步的功能，实现原理是添加
同步代码块。


2.1 ArrayList
    
  如何对ArrayList去除重复元素？
  方法一


import java.util.ArrayList;
import java.util.Iterator;


//去除一个ArrayList集合中的重复元素
//第二种方法使用hashSet()但顺序会打乱。
public class DeleteReElement {


public static void main(String[] args) {
ArrayList al  = new ArrayList();
al.add("a");
al.add("a");
al.add("a");
al.add("a");

System.out.println(single(al));
   }

public static ArrayList single(ArrayList al){
ArrayList al1 = new ArrayList();
Iterator it = al.iterator();
while(it.hasNext()){
if(!al1.contains(it.next())){
al1.add(it.next());
}
}
return al1;
}
}


方法二

ArrayList al= new ArrayList();
HashSet hs = new HashSet(al);
ArrayList a2 = new ArrayList(hs);


由此联想到StringBuffer（）（默认长度为16）


反转字符串：String s = "abcdefg";
  StringBuffer sb = new StringBuffer(s);
           sb.reverse().toString();





因为带有角标所以取元素时可以有两种方式
        ArrayList al = new ArrayList();
for(int i=0;i<al.size();i++){
System.out.println(al.get(i));
}

        Iterator it = al.Iterator();
while(it.hasNext()){
System.out.println(it.next());
}


Iterator和高级for循环的区别
对于Iterator可以在List内部对元素进行remove（）操作
ListIterator甚至还能进行增删改查
for()只能对元素进行遍历输出


增强for和传统for的区别
增强for适合用于集合（），而且必须要有遍历目标
传统for适合用于数组，能打印hello world 100次


在对List集合中的对象进行add（），remove（）时，要在对象中重写equals方法


class Person{
private String name;
private int age;
public boolean equals(Object obj){
if (!(obj instanceof Person))
throw new RuntimeException("类型不匹配");
Person p =(Person) obj;
return this.name.equals(p.name)&&this.age==p.age;
}
//在对hashSet集合中对象操作时复写hashCode（）
public int hashCode(){
return name.hashCode()+age*37;
}
//最好也复写toString方法
public String toString(){
  
          return (this.name+".."+this.age);
}
}




3.TreeSet TreeMap
TreeSet的底层是二叉树，按照自然顺序对元素进行排序
对自然排序的对象必须让他们具备比较能力，实现该能力有两种方法
一.实现Comparable接口，复写compareTo（）方法
class Student implements Comparable{
private String name;
private int age;
@Override
public int compareTo(Object o) {
if(!(o instanceof Student))
throw new RuntimeException("类型不匹配");

Student s = (Student)o;
if(this.age>s.age) return 1;
if(this.age==s.age) 
return this.name.compareTo(s.name);
else return -1;

}
}


二、在TreeSet中传入一个比较器 ，该比较器需要实现Comparator接口，
复写 int compare（Object o1,Object o2）


class Student implements Comparable{
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
private int age;
@Override
public int compareTo(Object o) {
if(!(o instanceof Student))
throw new RuntimeException("类型不匹配");

Student s = (Student)o;
if(this.age>s.age) return 1;
if(this.age==s.age) 
return this.name.compareTo(s.name);
else return -1;

}
}

class myComparator implements Comparator{

@Override
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 s1.getAge()-s2.getAge();
}
return num;
}

}



4.泛型

List<Integer,String> list = new ArrayList<Integer,String>();
集合中不能存放基本数据类型，在JDK1.5之后，对基本数据进行封装实现存放基本数据类型


哪些地方可以定义泛型？
1.集合
2.Iterator<String> it = list.iterator();
3.比较器
//可以在Comparator<super>,这样使其子类可以用父类的构造器
class MyComparator implements Comparator<String>{
public int compare(String o1,Stirng o2){
}
}
4.泛型类
class Util<T>{
private T obj;
public T getObject(T obj){
return obj;
}
}
5.泛型方法（将泛型定义在方法上更灵活）
class Demo{
public <T> void show(T t){}
public <T> void print(T t){}
}


泛型限定
ArrayList<? extends Person> ?：通配符 向上限定
ArrayList<? super Student>  向下限定


？和T的区别：？类型不明确，T只能表示一种类型




5.Map
Map以键值对的形式存储


map.put(k,v) 返回值为上一个V的值
如果 key相同，会覆盖原来的值


Map中没有迭代器，所以要将Map转换成Set，利用Set的迭代器进行迭代
取Map中元素两种方式：


//第一种取出方式keySet()
Set<Student> keySet = map.keySet();
Iterator<Student> it =keySet.iterator();
while(it.hasNext()){
Student stu = it.next();
String address = map.get(stu);
System.out.println(stu+"..."+address);
}

//第二种取出方式Map.Entry， Entry为Map的内部静态接口
Set<Map.Entry<Student, String>> set = map.entrySet();


Iterator<Map.Entry<Student, String>> it1 =set.iterator();
while(it1.hasNext()){
Map.Entry<Student, String> me = it1.next();
System.out.println(me.getKey()+"..."+me.getValue());
}


6.工具类
  Collections
  几个常用的方法
Collections.sort(List) 对List集合进行排序
Collection.sort(List,Comparator)
使用Collections.binarySearch()时要对集合先排序
如果没找到该元素时，返回（-插入点位置-1）
Collections.fill(List,""),集合按指点元素填充
Collections.reverseOrder(),返回一个比较器
Collections.reverseOrder(new MyComparator())可以传入自己的比较器
Collections.shuffle(List) 将集合中元素随机排放


在collection中实现了toArray()方法，可以将集合转化为数组


Arrays


Arrays.toString()


List = Arrays.asList(arr) 实现将数组转化为集合
String= Arrays.toString(T[])




7.方法的可变参数
public static void show(String s,int...arr){}
注意：可变参数要放在参数列表最后面




8.静态导入
import static java.util.Arrays.*;