java学习_集合(2)

1、泛型

(1)泛型概述

是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。

(2)格式：

<数据类型>

注意：该数据类型只能是引用类型。

(3)好处：

A:把运行时期的问题提前到了编译期间

B:避免了强制类型转换

C:优化了程序设计，解决了黄色警告线问题，让程序更安全

(4)泛型的前世今生

A:泛型的由来

存在安全隐患，java提供泛型来解决这个问题

B:泛型类  即把泛型定义在类上

public class objectTool<T>(){}

C:泛型方法 即把泛型定义在方法上

public <T> void show(T t){

System.out.println(t);

}

D:泛型接口  即把泛型定义在接口上

public interface Inter<T>(){}

E:泛型高级通配符

?

? extends E     向下限定，E及其子类

? super E       向上限定，E及其父类

(5)我们在哪里使用呢?

看API，如果类、接口、抽象类后面跟着有<E>就使用泛型，一般是在集合中使用。

2、JDK5的新特性包含：自动拆装箱、泛型、增强for、静态导入、可变参数、枚举

3、增强for循环

(1)是for循环的一种

(2)格式：

for(元素的数据类型 变量名 : 数组或者Collection集合的对象) {

使用该变量即可，该变量其实就是数组或者集合中的元素。

}

(3)好处：

简化了数组和集合的遍历

(4)弊端

增强for循环的目标不能为null。建议在使用前，先判断是否为null。

举例：

<span style="font-size:12px;"><span style="font-size:10px;">int [] arr={1,2,3,4,5};for(int x :arr){    System.out.println(x);}<pre name="code" class="java"></span></span>

4、静态导入

(1)可以导入到方法级别的导入

(2)格式：

import static 包名....类名.方法名;

(3)注意事项：

A:方法必须是静态的

B:如果多个类下有同名的方法，就不好区分了，还得加上前缀

所以一般我们并不使用静态导入，但是一定要能够看懂。

5、可变参数

(1)如果我们在写方法的时候，参数个数不明确，就应该定义可变参数。

(2)格式：

修饰符 返回值类型 方法名(数据类型... 变量) {}

注意：

A:该变量其实是一个数组名

B:如果一个方法有多个参数，并且有可变参数，可变参数必须在最后

(3)Arrays工具类的一个方法

asList()把数组转成集合。

注意：这个集合的长度不能改变。

6、练习   集合的嵌套遍历

<span style="font-size:12px;">import java.util.ArrayList;/* * 集合的嵌套遍历 * 需求： * 我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student> * 但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList<Student>。 * 而我现在有多个ArrayList<Student>。也要用集合存储，怎么办呢? * 就是这个样子的：ArrayList<ArrayList<Student>> */public class ArrayListDemo {public static void main(String[] args) {// 创建大集合ArrayList<ArrayList<Student>> bigArrayList = new ArrayList<ArrayList<Student>>();// 创建第一个班级的学生集合ArrayList<Student> firstArrayList = new ArrayList<Student>();// 创建学生Student s1 = new Student("唐僧", 30);Student s2 = new Student("孙悟空", 29);Student s3 = new Student("猪八戒", 28);Student s4 = new Student("沙僧", 27);Student s5 = new Student("白龙马", 26);// 学生进班firstArrayList.add(s1);firstArrayList.add(s2);firstArrayList.add(s3);firstArrayList.add(s4);firstArrayList.add(s5);// 把第一个班级存储到学生系统中bigArrayList.add(firstArrayList);// 创建第二个班级的学生集合ArrayList<Student> secondArrayList = new ArrayList<Student>();// 创建学生Student s11 = new Student("诸葛亮", 30);Student s22 = new Student("司马懿", 28);Student s33 = new Student("周瑜", 26);// 学生进班secondArrayList.add(s11);secondArrayList.add(s22);secondArrayList.add(s33);// 把第二个班级存储到学生系统中bigArrayList.add(secondArrayList);// 创建第三个班级的学生集合ArrayList<Student> thirdArrayList = new ArrayList<Student>();// 创建学生Student s111 = new Student("宋江", 40);Student s222 = new Student("吴用", 35);Student s333 = new Student("高俅", 30);Student s444 = new Student("李师师", 22);// 学生进班thirdArrayList.add(s111);thirdArrayList.add(s222);thirdArrayList.add(s333);thirdArrayList.add(s444);// 把第三个班级存储到学生系统中bigArrayList.add(thirdArrayList);// 遍历集合for (ArrayList<Student> array : bigArrayList) {for (Student s : array) {System.out.println(s.getName() + "---" + s.getAge());}}}}public class Student {private String name;private int age;public Student() {super();}public Student(String name, int age) {super();this.name = name;this.age = age;}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;}}</span>

7、Set集合

(1)Set集合的特点

无序,唯一

(2)HashSet集合

A:底层数据结构是哈希表(是一个元素为链表的数组)

B:哈希表底层依赖两个方法：hashCode()和equals()

执行顺序：

首先比较哈希值是否相同

相同：继续执行equals()方法

返回true：元素重复了，不添加

返回false：直接把元素添加到集合

不同：就直接把元素添加到集合

C:如何保证元素唯一性的呢?

由hashCode()和equals()保证的

D:开发的时候，代码非常的简单，自动生成即可。

E:HashSet存储字符串并遍历

F:HashSet存储自定义对象并遍历(对象的成员变量值相同即为同一个元素)

(3)TreeSet集合

A:底层数据结构是红黑树(是一个自平衡的二叉树)

B:保证元素的排序方式

a:自然排序(元素具备比较性)

让元素所属的类实现Comparable接口

b:比较器排序(集合具备比较性)

让集合构造方法接收Comparator的实现类对象

C:把我们讲过的代码看一遍即可

(4)案例：

A:获取无重复的随机数

B:键盘录入学生按照总分从高到底输出

8、Collection集合总结

Collection

|--List    有序,可重复

|--ArrayList

底层数据结构是数组，查询快，增删慢。

线程不安全，效率高

|--Vector

底层数据结构是数组，查询快，增删慢。

线程安全，效率低

|--LinkedList

底层数据结构是链表，查询慢，增删快。

线程不安全，效率高

|--Set   无序,唯一

|--HashSet

底层数据结构是哈希表。

如何保证元素唯一性的呢?

依赖两个方法：hashCode()和equals()

开发中自动生成这两个方法即可

|--LinkedHashSet

底层数据结构是链表和哈希表

由链表保证元素有序

由哈希表保证元素唯一

|--TreeSet

底层数据结构是红黑树。

如何保证元素排序的呢?

自然排序

比较器排序

如何保证元素唯一性的呢?

根据比较的返回值是否是0来决定                      

9、针对Collection集合我们到底使用谁呢?

唯一吗?

是：Set

排序吗?

是：TreeSet

否：HashSet

如果你知道是Set，但是不知道是哪个Set，就用HashSet。

否：List

要安全吗?

是：Vector

否：ArrayList或者LinkedList

查询多：ArrayList

增删多：LinkedList

如果你知道是List，但是不知道是哪个List，就用ArrayList。

如果你知道是Collection集合，但是不知道使用谁，就用ArrayList。

如果你知道用集合，就用ArrayList。

10、在集合中常见的数据结构

ArrayXxx:底层数据结构是数组，查询快，增删慢

LinkedXxx:底层数据结构是链表，查询慢，增删快

HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals()

TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序

11、Map

(1)将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

(2)Map和Collection的区别?

A:Map 存储的是键值对形式的元素，键唯一，值可以重复。（夫妻对）

B:Collection 存储的是单独出现的元素，子接口Set元素唯一，子接口List元素可重复。（光棍）

(3)Map接口功能概述

A:添加功能

V put(K key,V value) 添加元素

B:删除

void clear()  移除所有的键值对元素

V remove(Object key) 删除键对应的值，并返回键

C:判断功能

boolean containsKey(Object key) 判断元素中是否含有指定的键

boolean containsValue(Object value) 判断元素中是否含有指定的值

D:获取功能

Set<Map.Entry<K,V>> entrySet()  获取集合中所有键值对集合

V get(Object key) 根据键获取值

Set<K> keySet() 获取集合中所有键的集合

Collection<V> values() 获取集合中所有值的集合

E:长度功能

int size() 返回集合中键值对的数量

(4)Map集合的遍历

A:键找值

a:获取所有键的集合

b:遍历键的集合,得到每一个键

c:根据键到集合中去找值

B:键值对对象找键和值

a:获取所有的键值对对象的集合

b:遍历键值对对象的集合，获取每一个键值对对象

c:根据键值对对象去获取键和值

代码体现：

                        Map<String,String> hm = new HashMap<String,String>();hm.put("it002","hello");hm.put("it003","world");hm.put("it001","java");//方式1 键找值Set<String> set = hm.keySet();for(String key : set) {String value = hm.get(key);System.out.println(key+"---"+value);}//方式2 键值对对象找键和值Set<Map.Entry<String,String>> set2 = hm.entrySet();for(Map.Entry<String,String> me : set2) {String key = me.getKey();String value = me.getValue();System.out.println(key+"---"+value);

(5)HashMap集合的练习 HashMap<String,String>

import java.util.HashMap;import java.util.Set;/* * HashMap:是基于哈希表的Map接口实现。 * 哈希表的作用是用来保证键的唯一性的。 *  * HashMap<String,String> * 键：String * 值：String */public class HashMapDemo {public static void main(String[] args) {// 创建集合对象HashMap<String, String> hm = new HashMap<String, String>();// 创建元素并添加元素hm.put("it001", "aa");hm.put("it003", "bb");hm.put("it004", "cc");hm.put("it005", "dd");hm.put("it002", "ee); // wpshm.put("it001", "ff");              //由于键值对的唯一性，aa会被ff替换掉// 遍历 无序Set<String> set = hm.keySet();for (String key : set) {String value = hm.get(key);System.out.println(key + "---" + value);}}}

LinkedHashMap是Map接口的哈希表和链表的实现，具有可预知的迭代顺序

特点：

由哈希表保证键的唯一性

由链表保证键的有序(存储和取出的顺序一致)

代码体现

LinkedHashMap<String, String> hm = new LinkedHashMap<String, String>();// 创建并添加元素hm.put("2345", "hello");hm.put("1234", "world");hm.put("3456", "java");hm.put("1234", "javaee");hm.put("3456", "android");// 遍历Set<String> set = hm.keySet();for (String key : set) {String value = hm.get(key);System.out.println(key + "---" + value);}

(6)TreeMap集合的练习  TreeMap<String,String>

import java.util.Set;import java.util.TreeMap;/* * TreeMap:是基于红黑树的Map接口的实现。可以排序 *  * HashMap<String,String> * 键：String * 值：String */public class TreeMapDemo {public static void main(String[] args) {// 创建集合对象TreeMap<String, String> tm = new TreeMap<String, String>();// 创建元素并添加元素tm.put("hello", "你好");tm.put("world", "世界");tm.put("java", "爪哇");tm.put("world", "世界2");tm.put("javaee", "爪哇EE");// 遍历集合Set<String> set = tm.keySet();for (String key : set) {String value = tm.get(key);System.out.println(key + "---" + value);}}}

12、Collections

(1)是针对集合进行操作的工具类

(2)Collection和Collections的区别

A:Collection 是单列集合的顶层接口，有两个子接口List和Set

B:Collections 是针对集合进行操作的工具类，可以对集合进行排序和查找等

(3)常见的几个小方法：

A:public static <T> void sort(List<T> list)  根据元素默认情况下自然排序

B:public static <T> int binarySearch(List<?> list,T key) 二分查找

C:public static <T> T max(Collection<?> coll) 找最大值

D:public static void reverse(List<?> list)  反转

E:public static void shuffle(List<?> list) 随机置换

13、集合的总结

Collection(单列集合)

List(有序,可重复)

ArrayList

底层数据结构是数组,查询快,增删慢

线程不安全,效率高

Vector

底层数据结构是数组,查询快,增删慢

线程安全,效率低

LinkedList

底层数据结构是链表,查询慢,增删快

线程不安全,效率高

Set(无序,唯一)
让集合接收一个Comparator的实现类对象
自动生成hashCode()和equals()即可

HashSet

底层数据结构是哈希表。

哈希表依赖两个方法：hashCode()和equals()

执行顺序：

首先判断hashCode()值是否相同

是：继续执行equals(),看其返回值

是true:说明元素重复，不添加

是false:就直接添加到集合

否：就直接添加到集合

最终：

自动生成hashCode()和equals()即可

LinkedHashSet

底层数据结构由链表和哈希表组成。

由链表保证元素有序。

由哈希表保证元素唯一。

TreeSet

底层数据结构是红黑树。(是一种自平衡的二叉树)

如何保证元素唯一性呢?

根据比较的返回值是否是0来决定

如何保证元素的排序呢?

两种方式

自然排序(元素具备比较性)

让元素所属的类实现Comparable接口

比较器排序(集合具备比较性)

Map(双列集合)

A:Map集合的数据结构仅仅针对键有效，与值无关。

B:存储的是键值对形式的元素，键唯一，值可重复。

HashMap

底层数据结构是哈希表。线程不安全，效率高

哈希表依赖两个方法：hashCode()和equals()

执行顺序：

首先判断hashCode()值是否相同

是：继续执行equals(),看其返回值

是true:说明元素重复，不添加

是false:就直接添加到集合

否：就直接添加到集合

最终：

LinkedHashMap

底层数据结构由链表和哈希表组成。

            由链表保证元素有序。

            由哈希表保证元素唯一。

                 Hashtable
                       底层数据结构是哈希表。线程安全，效率低
                                哈希表依赖两个方法：hashCode()和equals()
                                执行顺序：
                                        首先判断hashCode()值是否相同
                                               是：继续执行equals(),看其返回值
                                                        是true:说明元素重复，不添加
                                                        是false:就直接添加到集合
                                              否：就直接添加到集合
                                最终：
                                         自动生成hashCode()和equals()即可
                TreeMap
                        底层数据结构是红黑树。(是一种自平衡的二叉树)
                                如何保证元素唯一性呢?
                                        根据比较的返回值是否是0来决定
                                如何保证元素的排序呢?
                                        两种方式
                                                自然排序(元素具备比较性)
                                                         让元素所属的类实现Comparable接口
                                                比较器排序(集合具备比较性)
                                                         让集合接收一个Comparator的实现类对象