Java中的集合（二）

泛型
创建集合对象使用泛型
好处：1.避免了类型装换的麻烦，存储的是什么类型，取出的就是什么类型。
2.把运行起异常，提升到了编译器
弊端：
泛型是什么类型，只能存储什么类型

ArrayList<String> list = new ArrayList<>();
list.add("abc");
list.add(1);//报错

定义一个含有泛型的类，模拟ArrayList集合
泛型是一个未知的数据类型，当我们不确定什么数据类型的时候，可以使用泛型
泛型可以接受任意的数据类型，可以使用Integer，String，Student…
创建对象的时候确定泛型的数据类型

定义含有泛型的方法：泛型定义在方法的修饰符和返回值类型之间
格式：
修饰符<泛型> 返回值类型 方法名 （参数列表（使用泛型））{
// 方法体
}
含有泛型的方法，在调用方法的时候确定泛型的数据类型
传递什么类型的参数，泛型就是什么类型

	//定义一个含有泛型的方法
public <M> void method01(M m){
	System.out.println(m);
	}
	//定义一个含有泛型的静态方法
public static <S> void method02 (S s){
	System.out.println(s);
	}

List 集合
extends Collection
有序、有索引、允许存储重复数字
java.util.List接口

注意：操作索引要防止索引越界异常

//创建一个List集合对象，多态
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");

list.add(3,"itheima");
String romoveE = list.remove(2);
String setE = list.set(4,"A");

//普通for循环
for(int i=0; i<list.size();i++){
	String s = list.get(i);
	System.out.println(s);
	}
//迭代器
Iterator<String> it = list.iterator();
while(it.hasNext){
	String s = it.next();
	System.out.println(s);
	}
//增强for 			
for(String s: list){	
	System.out.println(s);
	}		

ArrayList集合
主要用于查询数据、遍历数组

LinkedList集合
LinkedList集合特点：
1.底层是一个链表结构，查询慢，增删快
2.里面包含了大量操作首尾元素的方法
注意：使用LinkedList集合特有的方法，不能使用多态

//创建LinkedList集合对象
LinkedList<String>  linked = new LinkedList<>();
linked.add("a");
linked.add("b");
linked.add("c");
linked.add("d");
linked.add("e");

linked.addFirst("www");//相当于linked.push("www");
linked.addLast("www");//相当于Linked.add("www");
----------------------------------------------------
String first = linked.getFirst();
sout
String last = linked.getLast();
sout
----------------------------------------------------
String first = linked.removeFirst ();
sout
String last = linked.removeLast();
sout

Set集合
特点：不允许存储重复元素，没有索引，无序集合
HashSet集合
底层是一个哈希表结构（查询的速度非常的快）
哈希值是一个十进制的整数值。
哈希冲突：两个哈希值相同，里面的元素相同，equals方法返回true，两个元素相同（s1==s2);就不会把说存储到集合中。如果两个元素相同（s1不等于s2);就会把说存储到集合中，挂到s1下面。

LinkedHashSet集合特点：有序，不允许重复

Collections集合工具类使用方法

ArrayList<String> list = new ArrayList<>();
//list.add("a");
//list.add("b");
//list.add("c");
//list.add("d");
//list.add("e");
Collections.addAll(list,"a","b","c","d","e");//有序输出
Collections.shuffle(list,"a","b","c","d","e");//无序输出

Comparable接口的排序规则：
自己（this）-参数:升序
注意:自定义类型的排序，必须实现Comparable，重写接口中的方法compareTo定义排序规则

   ArrayList<Student> list02=new ArrayList<>();
        list02.add(new Student("迪丽热巴",18));
        list02.add(new Student("古力娜扎",20));
        list02.add(new Student("杨幂",17));
        System.out.println(list02 );
        Collections.sort(list02);
        System.out.println(list02 );
        ---------------------------------------------------------------
        public class Student  implements Comparable<Student> {
    private String name;
    private int age;
    @Override
    public int compareTo(Student o) {
        return this.getAge()-o.getAge();
    }
   }

Comparator：按指定规则排序

 ArrayList<Student> list02=new ArrayList<>();
        list02.add(new Student("迪丽热巴",18));
        list02.add(new Student("古力娜扎",20));
        list02.add(new Student("杨幂",17));
        Collections.sort(list02, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge()-o2.getAge();
            }
        });
        System.out.println(list02 );
    }