集合

1、List接口

List有序，可以存储重复元素

package LESSON11;
import java.util.ArrayList;
import java.util.Iterator;
public class demo1 {
//List接口实现类ArrayList
//数组结构，查询快，增删慢
    public static void main(String[] args) {
        ArrayList list=new ArrayList();
        list.add(1);
        list.add(2.2);
        list.add("133");
        list.add('a');
        System.out.println(list);
        System.out.println(list.isEmpty());
        System.out.println(list.size());
        System.out.println(list.contains(2));
        list.remove(1);
        System.out.println(list);
            
        ArrayList list2=new ArrayList();
        list2.add("arraylist");
        list2.add("linkedlist");        
       // list.add(list2);//添加集合
        list.addAll(list2);//添加集合中的元素
        System.out.println(list);
        System.out.println(list.containsAll(list2));
//        list.removeAll(list2);
//        System.out.println(list);
        list.retainAll(list2);
        System.out.println(list);
                
        ArrayList list3=new ArrayList();
        list3.add("张三");
        list3.add("李四");
        list3.add("王五");
        
        Object arr[]=list3.toArray();//返回一个数组
        for (int i = 0; i < arr.length; i++) {
//            System.out.println(arr[i]);
        }
        
        //遍历集合中的元素
        //1 for循环
        for (int i = 0; i < list3.size(); i++) {
            System.out.println(list3.get(i));    
        }
        System.out.println("------------------");
        //2 增强for循环
        for (Object o : list3) {
            System.out.println(o);            
        }
        System.out.println("------------------");        
        //3迭代器遍历
        Iterator it= list3.iterator();//将集合中的元素返回至迭代器中
        while(it.hasNext()){//判断迭代器是否有下一个元素
            System.out.println(it.next());//返回下一个元素
            
        }                        
    }
}

package LESSON11;
import java.util.LinkedList;
public class demo2 {
    /**
    List接口实现类LinkedList
    链表结构，查询慢，增删快
     */
    public static void main(String[] args) {
        LinkedList list=new LinkedList();
        list.add("Tom");
        list.add("rose");
        list.add("jerry");
        list.add("lucy");
        System.out.println(list);
        list.addFirst("john");
        list.addLast("marry");
        System.out.println(list);
        
        Object obj1=list.removeFirst();
        Object obj2=list.removeLast();
        System.out.println(obj1);
        System.out.println(obj2);
        System.out.println(list);        
    }
}

2、Set接口

package LESSON11;
import java.util.HashSet;
public class exercise {
    /**
     Set是一个无序的不能包含重复元素的接口。
     Set接口只包含从Collection继承过来的方法，增加了对add方法的限制，不允许有重复的元素。
     Set接口通用的实现类有HashSet、TreeSet和LinkedHashSet
     */
    public static void main(String[] args) {
        HashSet set1=new HashSet();
        HashSet set2=new HashSet();        
        String str[]={"java","html","css","js","bootstrap","html","java"};
        //把重复的元素存入一个集合，把不重复的元素存入另外一个集合
        for (int i = 0; i < str.length; i++) {    
            boolean bo=set1.add(str[i]);
            if(!bo){//如果向set1添加不成功
                set2.add(str[i]);//将元素添加到set2集合中
            }
        }
        set1.removeAll(set2);//移除重复元素
        System.out.println(set1);//不重复的元素
        System.out.println(set2);//重复的元素
       //两种遍历方式（无get方法）
        //1 增强for循环
        for (Object o : set1) {
            System.out.println(o);            
        }
        System.out.println("------------------");        
        //2迭代器遍历
        Iterator it= set1.iterator();//将集合中的元素返回至迭代器中
        while(it.hasNext()){//判断迭代器是否有下一个元素
            System.out.println(it.next());//返回下一个元素            
        } 
        HashSet set3=new HashSet();
        set3.add("张三");
        set3.add("李四");
        set3.add("王五");
        set3.add("赵六");
        System.out.println(set3);
        System.out.println(set3.contains("yan"));
        set3.remove("王五");
        System.out.println(set3);
        Object obj[]=set3.toArray();
        for (int i = 0; i <obj.length; i++) {
            System.out.println(obj[i]);
            
        }
        //set3.clear();
        HashSet set4=new HashSet();
        set4.add("张三");
        System.out.println(set3.size());
        
        set3.retainAll(set4);
        System.out.println(set3);                       
    }

}

3、Map接口

Map接口实现类
java.util.HashMap<K，V>     无序
java.util.TreeMap<K，V>      有序

package LESSON11;
import java.util.Collection;
import java.util.HashMap;
import java.util.Set;
public class demo3 {
    /**
     Map集合：以键值对形式存储
     键不能重复，值可以重复，键一旦重复，值会被覆盖
     */
    public static void main(String[] args) {
        HashMap map=new HashMap();
        map.put("1001", "张三");//向map集合添加元素
        map.put("1002", "李四");
        map.put("1003", "王五");
        map.put("1004", "赵六");
        System.out.println(map);
        System.out.println(map.get("1001"));//通过键获取到值
        map.remove("1004");//通过键移除元素
        System.out.println(map);
        System.out.println(map.size());//集合长度
        System.out.println(map.isEmpty());
        System.out.println(map.containsKey("1001"));
        System.out.println(map.containsValue("李四"));
        
        System.out.println("----------------------");
        HashMap map1 =new HashMap();
        map1.put("1001", "张三");
        map1.put("1002", "李四");
        map1.put("1003", "王五");
        Set set=map1.entrySet();//返回map集合元素至Set视图
        for (Object o : set) {
            System.out.println(o);
            
        }
        
        Set set1=map1.keySet();//返回map集合中的键至Set视图
        for (Object o : set1) {
            System.out.println(o+"="+map1.get(o));//遍历Map集合
            
        }
        System.out.println("---------------------");
        Collection coll=map1.values();//返回map集合中的键至Set视图
        for (Object o : coll) {
            System.out.println(o);            
        }
        
        HashMap map2 =new HashMap();
        map2.put("1005", "小明");
        map2.put("1006", "晓明");
        map1.putAll(map2);//添加map集合中的元素
        System.out.println(map1);
    }
}

4、泛型

泛型就是广泛的数据类型

好处：无需转型

泛型类

泛型方法

泛型接口

package LESSON11;
import java.util.ArrayList;
import java.util.HashMap;
class User{
    String name;
    public User(String name) {
        this.name=name;
    }
    
}
public class demo4{
    
    public static void main(String[] args) {
        
         ArrayList<Integer> list=new ArrayList<Integer>();
         list.add(123);
         list.add(456);
         
         HashMap<String, String> map= new HashMap<String, String>();
         map.put("1001", "杨园园");
         map.put("1002", "詹三");
        
         ArrayList<User> list2=new ArrayList<User>();
         list2.add(new User("战狼"));
         list2.add(new User("亮剑"));
         list2.add(new User("雪豹"));
         
         for (int i = 0; i < list2.size(); i++) {
             System.out.println(list2.get(i).name);
            
        }             
    }

}

package LESSON11;

//泛型接口
interface A<F>{
    public F create(F f);
    
}
class Admin{
    String name;
}
class B implements A<Admin>{
    @Override
    public Admin create(Admin admin) {
        // TODO Auto-generated method stub
        return admin;
    }
}
//泛型类
public class demo6<T> {
    public T t;
    
    //泛型方法
    public T test(){
        return t;
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        demo6<Double> demo=new demo6<Double>();
        demo.t=3.14;
        demo.test();

    }

}

 5、工具类

Collections工具类和Arrays工具类

package LESSON11;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;//导入工具类的包，不是Collection，Collection是集合
import java.util.List;

public class demo5 {

    public static void main(String[] args) {
        /**
    Collections提供了集合操作的常用算法，这些算法都以静态方法的形式提供，
    这些静态方法的第一个参数都是需要对其操作的集合。
         */
        ArrayList<Integer> list=new ArrayList();
        list.add(11);
        list.add(3);
        list.add(2);
        list.add(44);
        list.add(88);
        Collections.sort(list);//排序，默认升序
        Collections.reverse(list);//反转集合中的顺序
        System.out.println(list);
        Collections.shuffle(list);//随机排序
        System.out.println(list);
        System.out.println(Collections.max(list));//查找极大值
        System.out.println(Collections.min(list));//查找极小值
        System.out.println();
        
        
        /*Arrays
         * 此类包含用来操作数组（比如排序和搜索）的各种方法。*/
        int a[]={22,11,55,33,66};
        Arrays.sort(a);//排序，默认升序
        
        List<int[]> list2=Arrays.asList(a);//返回一个受指定数组支持的固定大小的列表。
        //System.out.println(list2);//集合地址 [[I@1e58cb8]
        for (int i = 0; i < list2.size(); i++) {
            for (int j = 0; j < a.length; j++) {
                //System.out.println(list2.get(i));//数组地址 [I@1e58cb8
                System.out.println(list2.get(i)[j]);//遍历集合中的数组
            }
            
        }
        System.out.println();
        int a2[]=Arrays.copyOf(a, 3);//复制数组
        for (int i = 0; i < a2.length; i++) {
            System.out.println(a2[i]);
        }
        
        Arrays.fill(a2, 100);//初始化数组
        for (int i = 0; i < a2.length; i++) {
            System.out.println(a2[i]);//全为100.
        }


    }

}