Java基础学习（八）

---

一、Collection顶层接口（单列）

• 注意：集合中的元素必须是引用数据，会涉及到拆箱和装箱的问题，而数组可以是引用也可以是基本数据类型
• Collection是单列集合的顶层接口,不能创建对象，只能创建子类对象
• Collection类型的变量只能调用在Collection中已经声明的方法，不能调用子类特有的，要想调用，需向下转型
• 通过多态的方式使用
• 集和的实现类ArrayList和LinkedList，Hashset和Treeset
• 没有get索引的方法，遍历需调用迭代器。

常用方法

代码演示如下

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.TreeSet;

public class CollectionTest {
    public static void main(String[] args) {
        //此处以ArrayList对象为例，介绍collecti的方法
        Collection<String> collection1 = new ArrayList<>();
        System.out.println("没有添加元素前");
        System.out.println(collection1);
        System.out.println("添加两个元素后");
        collection1.add("zs");//成功返回true
        collection1.add("ls");
        collection1.add("ww");
        System.out.println("集合中元素的个数为" + collection1.size());
        System.out.println(collection1);
        System.out.println("移除一个元素后");
        collection1.remove("ls");//成功返回true
        System.out.println(collection1);
        System.out.println("查找元素是否在集合中");
        System.out.println(collection1.contains("ls"));
        System.out.println("清空元素");
        collection1.clear();//没有返回值
        System.out.println(collection1);
        System.out.println("判断集合是否为空");//是指内容为空
        System.out.println(collection1.isEmpty());
        System.out.println("============迭代器举例===========");
        //TreeSet根据元素的自然排序进行排序，后续介绍
        Collection<Character> collection2 = new TreeSet<>();
        collection2.add('2');
        collection2.add('3');
        collection2.add('1');
        collection2.add('4');
        System.out.println(collection2);
        Iterator<Character> i=collection2.iterator();
        while (i.hasNext()){
            System.out.println(i.next());
        }
        System.out.println("============增强for遍历=========");
        for(Character c:collection2){
            System.out.println(c);
        }
    }
}

---

二、List接口(可重复）

1.List继承Collection

• List也是接口，继承Collection,Collection的方法，List都可用,需创建子类对象
• 有序集合(序列),可以精准的控制元素的插入位置，可以通过索引来访问元素
• 有序:存储和取出的元素顺序一样
• 可重复:存储的元素可以重复

特殊方法

• E get(int index) 返回列表中指定位置的元素。
• int indexOf(Object o) 返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
• boolean addAll(int index, E c) 在集合中指定位置插入元素
• E set(int index,E element) 修改指定元素，并返回被修改元素
• int lastIndexOf(Object o) 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。

代码演示

public class ListTest {
    public static void main(String[] args) {
        //以LinkedList为实例化的对象
        List<Integer> list=new LinkedList<>();
        list.add(2);
        list.add(1);
        list.add(3);
        list.add(2);
        list.add(1);
        System.out.println("当前集合:"+list);
        System.out.println("集合长度："+list.size());
        System.out.println("输出索引值为3的元素："+list.get(3));
        System.out.println("输出1第一次出现的索引："+list.indexOf(1));
        System.out.println("输出最后一次出现的索引："+list.lastIndexOf(1));
        list.add(2,10);
        System.out.println("插入10之后："+list);
        list.set(0,19);
        System.out.println("将索引为0的位置值改为19："+list);
        System.out.println("===========迭代器遍历==========");
        Iterator<Integer> i=list.iterator();
        while(i.hasNext()){
            System.out.println(i.next());
        }
        System.out.println("============增强for遍历=========");
        for(Integer a:list){
            System.out.println(a);
        }
        System.out.println("============for循环遍历=========");
        for (int j=0;j<list.size();j++){
            System.out.println(list.get(j));
        }
    }
}

2.ArrayList类

• Arraylist数组结构，查询快，增添慢，List和Collection中的方法都能用
• public ArrayList()构造一个初始容量为 10 的空列表
• public ArrayList(int initialCapacity)构造一个具有指定初始容量的空列表。
• 线程不安全

代码演示

public class ArraylistTest {
    public static void main(String[] args) {
        //随便举个用法，并非特有
        ArrayList<String> arrayList1=new ArrayList<>();
        arrayList1.add("d");
        arrayList1.add("3");
        arrayList1.add("5");
        ArrayList<String> arrayList2=new ArrayList<>();
        //此方法Collection也有
        arrayList2.addAll(arrayList1);
        System.out.println(arrayList1);
        System.out.println(arrayList2);
        }
}

3.LinkedList

• LinkedList链表结构,和Arraylist集合用法类似，拥有list的所有方法
• Linkedlist增删快，查找慢
• 线程不安全，效率低

特有方法

• void addFirst(E e) 在列表开头插入指定元素
• void addLast(E e) 在列表末尾追加指定元素
• E getFirst() 返回列表第一个元素
• E getLast() 返回列表末尾元素
• E removeFirst() 移除第一个元素并返回
• E removeLast() 移除末尾元并返回

代码演示

public class LinkedListTest {
    public static void main(String[] args) {
        LinkedList<String> linkedList=new LinkedList<>();
        linkedList.add("123");
        linkedList.add("234");
        linkedList.add("123");
        linkedList.add("345");
        System.out.println(linkedList);
        System.out.println("在列表开头插入指定元素,获取第一个元素");
        linkedList.addFirst("355");
        System.out.println(linkedList);
        System.out.println(linkedList.getFirst());
        System.out.println("在末尾追加指定元素，获取末尾元素");
        linkedList.addLast("3435");
        System.out.println(linkedList);
        System.out.println(linkedList.getLast());
    }
}

---

三、Set接口（不可重复）

1.Set继承Collection

• Set也是接口，继承Collection,Collection的方法set都可用,需创建子类对象
• 不包含重复元素的集合
• Set集合没有索引方法，不能使用for循环遍历
• 不能保证存储和取出的顺序一致

代码演示

public class SetTest {
    public static void main(String[] args) {
        Set<String> set=new HashSet<>();
        set.add("123");
        set.add("344");
        set.add("123");
        //不包含重复元素，重复会覆盖
        System.out.println(set);

    }
}

2.Hashset实现Set

• 哈希值概述:
  根据对象的地址值或者字符串或者数字计算得到的int类型的数值
  Obeject中可以通过方法来获取哈希值
• public void hasCode():返回对象的哈希值,Collection也有

特点

• 同一个对象多次调用hasCode()方法返回的哈希值是相同的
• 默认情况下，不同对象的的哈希值是不同的，通过重写hasCode(),可以实现让不同对象的哈希值相同

hashset概述

• 由哈希表（实际为HashMap实例）支持。 对集合的迭代次序不作任何保证
  特点:
• 底层数据结构是哈希表
• 对集合的迭代顺序不进行任何保证，就是存储和取出的顺序不一定相同
• 没有带索引的方法，不能使用for循环遍历
• 继承Set集合，元素不能重复

代码演示

public class HashsetTest {
    public static void main(String[] args) {
        String s1="234";
        String s2=new String("234");
        String s3="234";
        String s4=new String("234");
        System.out.println(s1==s2);//比较地址
        System.out.println(s1.equals(s2));//比较值
        System.out.println(s1==s3);
        System.out.println(s1.equals(s3));
        System.out.println(s2==s4);
        System.out.println(s2.equals(s4));
        System.out.println("=====================");
        HashSet<String> hashSet=new HashSet<>();
        hashSet.add("a");
        hashSet.add("c");
        hashSet.add("b");
        hashSet.add("a");
        hashSet.add("d");
        System.out.println(hashSet);
    }
}

3.TreeSet继承Set

Treeset概述:

• 元素有序,不是存储或取出有序,而是按照一定的规则进行排序,排序方式取决于构造方法
• TreeSet():根据元素的自然排序进行排序
• TreeSet(Comparator comparator):根据指定的比较器比较

特点

• 元素有序
• 没有带索引的方法，不能使用for循环遍历
• 继承Set集合，元素不能重复

代码演示

public class Treeset {
    public static void main(String[] args) {
        TreeSet<String> treeSet=new TreeSet<>();
        treeSet.add("a");
        treeSet.add("c");
        treeSet.add("b");
        treeSet.add("a");
        treeSet.add("d");
        System.out.println(treeSet);
    }
}

4.比较器

比较器一般用于Treeset有序集合，其他集合的实例化不可以使用

1.Comparator接口，用于对象

• 接口 Comparator

类型参数

• T - 此 Comparator 可以比较的对象类型

• 强行对某个对象 collection 进行整体排序 的比较函数。

• int compare(T o1, T o2)
  比较用来排序的两个参数。，To1 为当前插入的，To2为已经插入的

• compareTo和compare返回值为0 认为两个元素相同,只输出一个，其他被覆盖
  compareTo返回值为负 逆序序输出
  compareTo返回值为正 原序输出
  即从小到大：o1-o2
  从大到小： o2-o1

public class ComparaTest {
    public static void main(String[] args) {
        Collection<String> collection=new TreeSet<>(new Comparator<String>(){
            @Override
            public int compare(String o1, String o2) {
                int i=o2.compareTo(o1);
                return i;
            }
        });
        collection.add("e");
        collection.add("a");
        collection.add("b");
        collection.add("f");
        collection.add("c");
        System.out.println(collection);

    }
}

2.Comparable 接口，用于类

• 接口 Comparable

类型参数

• T - 可以与此对象进行比较的那些对象的类型
• 此接口强行对实现它的每个类的对象进行整体排序。
• 这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。
• int compareTo(T o),T o对象为已经插入的，this为当前的
  比较此对象与指定对象的顺序。
  this-o: 从小到大
  o-this：从大到小

代码演示

public class Treeset implements Comparable<Treeset>{
    private int a;

    public Treeset(int a){
        this.a=a;
    }

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }


    @Override
    public String toString() {
        return "Treeset{" +
                "a=" + a +
                '}';
    }

    @Override
    public int compareTo(Treeset o) {
        int i=this.getA()-o.getA();//this为当前插入的，o是之前的
        return i;
    }
}

import java.util.TreeSet;

public class Test {
    public static void main(String[] args) {
        Treeset t1=new Treeset(23);
        Treeset t2=new Treeset(34);
        Treeset t3=new Treeset(20);
        Treeset t4=new Treeset(21);

        TreeSet<Treeset> t=new TreeSet<>();
        t.add(t1);
        t.add(t2);
        t.add(t3);
        t.add(t4);
        System.out.println(t);
    }
}

四、map接口

Map概述

• Interface Map<K,V> K:键的类型 V:值的类型,接口，创建对象需要具体的实现类hashmap
• 将键映射到值的对象，不能包含重复的键,每个键可以映射最多一个值,含有重复键会覆盖value值

举例
1001=张三
1002=李四
1003=张三
创建对象:
通过多态的形式
通过具体的实现类HashMap

• V put(K key,V value) 添加元素
• V remove(Object key) 根据key移除元素
• void clear() 清空集合
• boolean containsKey(Object key) 判断集合中是否包含指定key
• boolean containsValue(Object value) 判断集合中是否包含指定value
• boolean isEmpty() 判断集合是否为空
• int size() 集合的长度
• V get(Object key) 根据key获取value
• Set keySet() 获取所有key的集合
• Collection values() 获取所有value的集合
• Set<Map.Entry<K,V>> entrySet() 获取所有KV的集合
• Map集合中的元素都是成对出现,K映射V

实例
Hashmap:线程不安全
Hashtable:线程安全
SortedMap

遍历格式1:
通过获取k的集合 去查找v
1.调用keySet()方法
2.增强for循环遍历
3.循环体中调用get(Object key)方法
遍历格式2:
通过获取KV集合
1.调用entrySet()方法
2.增强for循环遍历
3.循环体中调用getKey()方法/getvalue()

map的基本功能

map的获取功能

map遍历

代码演示

public class Maptest {
    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<>();
        map.put(003,"sq");
        map.put(02,"ls");
        map.put(34,"zs");
        System.out.println(map);
        System.out.println("删除003键值:"+map.remove(003));
        System.out.println(map.containsKey("是否含有key为003的元素:"+"003"));
        System.out.println(map.containsValue("是否含有zs:"+"zs"));
        System.out.println("集合长度为:"+map.size());
        System.out.println("判断是否为空："+map.isEmpty());
        System.out.println("获取键值为02的值"+map.get(02));
        System.out.println("=========获取key的集合=======");
        Set<Integer> key1=map.keySet();
        System.out.println(key1);
        System.out.println("=========获取值得集合==========");
        Collection<String> value1=map.values();
        System.out.println(value1);
        System.out.println("========获取所有元素的集合========");
        Set<Map.Entry<Integer, String>> se1=map.entrySet();
        System.out.println(se1);
        System.out.println("====遍历map集合元素方法1==========");
        for(Integer i:key1){
            System.out.println(i+"========="+map.get(i));
        }
        System.out.println("======遍历map集合方法2============");
        for(Map.Entry<Integer,String> mm:se1){
            System.out.println(mm.getKey()+"=========="+mm.getValue());
        }


    }

}

五、泛型

概述

• 提供了编译时类型安全监测机制,允许在编译时检测到非法类型
  本质上是参数化类型,也就是说操作的参数被指定为一个数据类型
  参数分为形参和实参，在方法中定义方法时有形参,实际调用时传递实参
  而参数化类型,就是将类型由原来具体的类型参数化,在使用/调用时传入具体的参数
• 参数化类型可以用在类,方法,接口中,分别称为泛型类,泛型方法,泛型接口

格式

• <类型>:指定一种类型的格式,这里类型可以看做形参
• <类型1,类型2…>:指定多个类型,类型之间用逗号隔开,这里类型可以看做形参
  在具体调用时给定的类型可以看成实参,实参只能是引用数据类型

1.泛型方法

格式

• 访问修饰符 <类型> 返回值 方法名称(类型 变量名)

范例

• public void show(T t)

注意:这里的T是一个标识,可以为任意标识,常见的如K V T E等用于表示泛型

2.泛型类

格式

• 访问修饰符 class 类名<类型>{}

范例

• public class Student

注意:这里的T是一个标识,可以为任意标识,常见的如K V T E等用于表示泛型
泛型类中的 成员变量或者成员方法 也加上了泛型
成员变量或者成员方法上的泛型和泛型类保持一致

3.泛型接口

格式

• 访问修饰符 interface 接口名称<类型>{}

范例

• public interface Impl

注意:这里的T是一个标识,可以为任意标识,常见的如K V T E等用于表示泛型

代码演示

interface Inter<T>{
    void sum(T a);
}
//类实现接口时，类的泛型和接口的泛型都要写
class InterImly<T> implements Inter<T>{
    @Override
    public void sum(T a) {
        System.out.println(a);
    }
}
public class Genericity {
    public static void main(String[] args) {
        //输入指定类型，输入其他类型将报错
        InterImly<Integer> a1=new InterImly<>();
        a1.sum(12);
        InterImly<Double> a2=new InterImly<>();
        a2.sum(3.0);
        InterImly<String> a3=new InterImly<>();
        a3.sum("faf");
        //没有给出指定类型，默认为object类型，可以装任何类型
        InterImly a4=new InterImly();
        a4.sum(12);
        a4.sum(12.0);
        a4.sum("STR");


    }
}

六、可变参数

概述

• 可变参数就是方法的参数个数可以发生变化
• 格式:修饰符 返回值类型 方法名(数据类型…变量名){}
• 范例:public static void sum(int…i)

注意

• 可变参数其实就是一个集合
• 如果方法中有多个参数,并包含可变参数,可变参数放在最后
• 不能同时使用多个可变参数

代码演示

//可变参数
public class Param {
    public static void main(String[] args) {
        System.out.println(sum(2,3,4,5));
        System.out.println(sum(2,2));
        System.out.println(summ(100,1,2,3));
        System.out.println(summ(1000,3,3));
    }

    public static int sum(int...i){
        int sum=0;
        for(int j=0;j<i.length;j++){
            sum+=i[j];
        }

        return sum;
    }

    public static int summ(int i,int...j){
        int sum=0;
        for(int x=0;x<j.length;x++){
            sum=sum+j[x];
        }
        return sum+i;
    }
}

七、总结

ArrayList数组结构
	数组是一种查询快，增删慢的模型
	查询快:查询数据通过索引定位，查询任意数据耗时相同 
	删除慢:删除元素时,要讲原始数据删除,同时元素进行前移
	添加慢:添加元素时,要在添加位置的每一个数据进行后移,再添加元素
LinkedList链表结构
	链表是一种增删快，查询慢的模型
	增删快:增加和删除时,只需要修改下一个地址指向，耗时相同
	查询慢:查询数据时,都需要从头开始查询
获取系统时间
	System.currentTimeMillis()结果是时间戳
	时间戳:当前时间减去格林威治时间得到的秒数

哈希值:通过调用Object中hashCode()方法获取哈希值
	哈希值不是地址值,使用过地址值和数字得到的int类型的数据
	默认情况下不同对象的哈希值都是不同的(特殊情况就是String通话和重地)

HashSet:无序 没有通过索引获取元素的方法 去重
	内存存储机制(如何去重)
	1.通过hashCode()获取添加元素的哈希值
	2.哈希值对16进行取模 得到存储的位置
	3.如果当前位置为空,直接进行添加
	4.如果不为空,对当前位置上所有元素一一进行比较,如果地址值,和equals有一个不同,进行进行添加,否则覆盖
	注意:HashSet数据结构是哈希表(HashMap),哈希表由数组和链表组成
Comparable:接口 让实现这个接口的类可以进行整体排序(自然排序)
	使用方式:1.实现Comparable接口
			2.重写CompareTo方法
			3.重写CompareTo方法中return只有三种情况
				3.1:0 看做相同元素,进行覆盖
				3.2:正 按照添加的进行输出
				3.3:负 按照添加的进行倒着输出
			注意:this表示插入的数据
Comparator:接口 通过构造作为参数进行传递,使用匿名类的情况进行参数传递
	使用方式:1.Comparator作为参数进行传递
			2.重写Compare方法
			3.重写Compare方法中return只有三种情况
				3.1:0 看做相同元素,进行覆盖
				3.2:正 按照添加的进行输出
				3.3:负 按照添加的进行倒着输出
			注意:o1表示插入的数据
排序中所有排序方式都是int相加减
	比如是String的中文,首先转化为char[],然后一个char一个char的相比较(转化为int进行比较)
泛型:限制集合中存储的数据类型
     参数化类型
     	形参:类定义上,接口定义上,方法定义上
     	实参:使用或调用过程中,给的具体的数据类型
     	注意:实现一个泛型接口时,实现类也需要加上泛型
     		 形参<>中的内容,只是一个标识,可以任意给内容,通常使用K,V,T,E表示泛型
可变参数:
	格式:访问修饰符 返回值类型 方法名(数据类型...变量名){}
	例如:public void sum(int...ints){}
	注意:可变参数等同于数组
		 多个参数,可变参数只能放在最后
		 不能同时使用多个可变参数

八、习题

一、填空题
1.Java集合框架提供了一套性能优良、使用方便的接口和类，包括Collection和Map两大类，它们都位于__util___ 包中

2.队列和堆栈有些相似，不同之处在于 栈是先进后出，队列是先进先出 。

3.   链表      结构是一种由多个节点组成的线性数据结构，并且每个节点包含有数据以及指向下一个节点的引用。

4._____LinkedList________是一种集合类，它 采用链表作为存储结构，便于删除和添加元素，但是按照索引查询元素效率低下。

5.     TreeSet         是一种Collection类型的集合类，其中元素唯一，并采用二叉树作为存储结构，元素按照自然顺序排列。

6.如果希望将自定义类Student的多个对象放入集合TreeSet，实现所有元素按照某个属性的自然顺序排列，则需要Student类实现_____comparable____________接口。

7.在Java中      HashMap      集合的访问时间接近稳定，它是一种键值对映射的数据结构。这个数据结构是通过数组来实现的。

8.迭代器Iterator为集合而生，专门实现集合遍历，该接口有三个方法，分别是hasNext() 、_____next()_______、remove()。

二、选择题
1.	以下选项中关于Java集合的说法错误的是（   AC）。（选择二项）
		
	A.	List接口和Set接口是Collections接口有两个子接口
	B.	List接口中存放的元素具有有序，不唯一的特点
	C.	Set接口中存放的元素具有无序，不唯一的特点
	D.	Map接口存放的是映射信息，每个元素都是一个键值对

2.	如下Java代码，输出的运行结果是（ A）。（选择一项）
	public class Test {
	public static void main(String[ ] args) {
		List list=new ArrayList();
		list.add("str1");
		list.add(2, "str2");
		String s=list.get(1);
		System.out.println(s);
	}
}
		
	A	运行时出现异常
	B.	正确运行，输出str1
	C.	正确运行，输出str2
	D.	编译时出现异常

3.	以下Java代码的作用是首先将一个数组的内容存入集合，然后判断集合中是否有指定的元素存在，其中共有（ D  ）处错误。（选择一项）
import java.util.List;
public class Test {
public int getIndexofArray(float[] f){
	int rtn=-1;
	float objf=3.4;
	List list=null;
	for(int i=0;i<f.size( );i++){
		list.add(f[i]);
	}
	for(int i=0;i<list.size( );i++){
		float tmp=(float)list.get(i);
		if(objf==tmp){
			rtn=i;
		}
	}
	return rtn;
}	

}

A	0
B.	1
C.	2
D.	3

	
4.	分析如下Java 代码，编译运行后将输出（  B  ）。（选择一项）
	public class Test {
	public Test() {
	}
	static void print(List al) {
		al.add(2);
		al = new ArrayList();
		al.add(3);
		al.add(4);
	}
	public static void main(String[] args) {
		List al = new ArrayList();
		al.add(1);
		print(al);
		System.out.println(al.get(1));
	}
}
		
	A	1
	B.	2
	C.	3
	D.	4
5.	在Java中,下列集合类型可以存储无序、不重复的数据的是（  D  ）。（选择一项）
		
	A	ArrayList
	B.	LinkedList
	C.	TreeSet
	D.	HashSet

6.	以下代码的执行结果是（ C   ）。（选择一项）
	Set s=new HashSet();
	s.add("abc");
	s.add("abc");
	s.add("abcd");
	s.add("ABC");
	System.out.println(s.size());
		
	A.	1
	B.	2
	C.	3
	D.	4
	

7.	给定如下Java代码，编译运行的结果是（ C  ）。（选择一项）
public class Test {
public static void main(String[] args) {
	Map<String, String> map = new HashMap<String, String>();
	String s = "code";
	map.put(s, "1");
	map.put(s, "2");
	System.out.println(map.size());
}
}
	
A	编译时发生错误
B.	运行时引发异常
C.	正确运行，输出：1
D.	正确运行，输出：2

8.	下面集合类中属于非线程安全，且结构采用了哈希表的是（  C ）。（选择一项）
		
	A.	Vector
	B.	ArrayList
	C.	HashMap
	D.	Hashtable

9.	
在Java中，LinkedList类与ArrayList类同属于集合框架类，下列（  CD ）选项中是LinkedList类有而ArrayList类没有的方法。（选择两项）
		
	A	add(Object o)
	B.	add(int index,Object o)
	C.	getFirst()
	D.	removeLast()
	

三、判断题
1.数组和集合中的元素可以是任何数据类型，包括基本类型和引用类型。( X)

2.Java集合中的Set接口和List接口都是从Collection接口派生出来的。（ T ）

3.Collection 接口存储一组不唯一，有序的对象，它有两个子接口：List和Set。（  X  ）

4.Collection是Java集合顶级接口，其中的元素无序，唯一。Java平台不提供这个接口任何直接的实现。（ X   ）

5.List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引来访问List中的无素，这类似于Java的数组。（ T  ）

6.HashSet采用哈希表存储结构，特点是查询速度快，但是其中元素无序排列。（  T  ）

7.LinkedHashMap是一种有序的HashMap，查询速度快，便于添加删除操作。（  T  ）

8.基本数据类型的值可以被直接存储在Vector对象中。（  X ）

9.Dictionary建立了关键字和值的映射，只要提供一个关键字，Dictionary就会返回一个相应的值。（  T  ）

10.泛型是JavaSE1.7(1.5)的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。Java语言引入泛型的好处是安全简单。（ X  ）
解析：好处是关于类型的错误在编译前期就可以发现

11.CollectionS是专门操作集合的工具类，提供一系列静态方法实现对各种集合操作。（X）

12.Iterator接口可以遍历任何Collection接口的实现类，可以从一个Collection中使用iterator( )方法来获取迭代器实例。迭代器取代了Java集合框架中的Enumeration。<

四、简答题
1.集合和数组的比较 

	.1）数组是大小固定的，并且bai同一个数组只能存放类型一样的数du据（基本类型/引用类型）
	.2）JAVA集合可以存储和操作数目不固定的一组数据。
	.3）JAVA集合只能存放引用类型的的数据，不能存放基本数据类型；数组可以。
	.（注意基本类型int,double等等，但是Integer,Double等是类类型了）

2.简述List、Set、Collection、Map的区别和联系。

collection
	Collection是最基本的集合接口，声明了适用于JAVA集合（只包括Set和List）的通用方法。Map接口并不是Collection接口的子接口，但是它仍然被看作是Collection框架的一部分。
list
	List的长度可变。 List集合像一个数组，是有序的。保持了每个元素的插入顺序，输出的顺序就是插入的顺序。 可以插入多个null元素。 List可以通过index知道元素的位置，它允许元素的重复。ArrayList, LinkedList, Vector可以实现List接口。
set
	无序容器，你无法保证每个元素的存储顺序 TreeSet通过 Comparator 或者 Comparable 维护了一个排序顺序。 只允许一个 null 元素 Set集合是无序的，元素不允许重复。HashSet, LinkedHashSet,TreeSet 可以实现Set接口。
map
	Map不是collection的子接口或者实现类。Map是一个接口。 Map 里你可以拥有随意个 null 值但最多只能有一个 null 键。 Map(interface): 使用键值对(key-value), 值(value)可以重复，键(key)不可以重复。HashMap, LinkedHashMap, Hashtale, TreeMap可以实现Map接口。
	

3.ArrayList和LinkedList的区别和联系。

A、区别
	1.ArrayList是实现了基于动态数据的数据结构，LinkedList是基于链表结构实现。
	2.对于随机访问的get()和set()方法，ArrayList的效率要高于LinkedList，因为LinkedList要移动指针。
	3.对于增加和删除操作的add()和remove()方法，LinkedList效率要高于ArrayList，因为ArrayList要移动数据。
B、联系
	1.ArrayList和LinkedList都是List接口的实现类，这两个类都是对List进行操作。
	2.List接口里定义了它们必须要实现的方法，比如add(E)、get(int)、remove(int)、set(E)等基本的List操作，然后这两个类就按照它们自己的方法来实现这些List的基本操作。
	3.都是有序，可重复的，线程不安全


4.HashSet采用了哈希表作为存储结构，请说明哈希表的特点和实现原理。
提示：结合Object类的hashCode()和equals()说明其原理

哈希表的本质就是“数组+链表”，结合了两者的优点，查询快，增删效率也高
hashCode()方法用来计算key的哈希值，equals()方法用来判断两个键值对中的key是否相等。

存储数据过程put(key,value)
哈希表的本质就是“数组+链表”
第一步：获得key对象的hashcode
第二步：根据hashcode计算出hash值(要求在[0, 数组长度-1]区间)
第三步：生成Entry对象，一个Entry对象包含4部分：key对象、value对象、hash值、指向下一个Entry对象的引用。
第四步：将Entry对象放到table数组中

当添加一个元素(key-value)时，首先计算key的hash值，以此确定插入数组中的位置，但是可能存在同一hash值的元素已经被放在数组同一位置了，这时就添加到同一hash值的元素的后面，他们在数组的同一位置，就形成了链表，同一个链表上的Hash值是相同的，所以说数组存放的是链表。 JDK8中，当链表长度大于8时，链表就转换为红黑树，这样又大大提高了查找的效率。

取数据过程get(key)
(1) 获得key的hashcode，通过hash()散列算法得到hash值，进而定位到数组的位置。
(2) 在链表上挨个比较key对象。 调用equals()方法，将key对象和链表上所有节点的key对象进行比较，直到碰到返回true的节点对象为止。
(3) 返回equals()为true的节点对象的value对象。


5.Vector和ArrayList的区别和联系。

Vector和ArrayList的相同点：
	1.都是容量大小动态可变的数组。
	2.都可以快速随机的内部元素进行访问。
不同点：
	1.Vector线程安全，ArrayList线程不安全
	2.Vector是唯一一个既有Enumeration，又有Iterator进行遍历的类，而ArrayList只有Iterator.
在Vector里面有个方法可以对其增长的大小进行设定而ArraryList是没有这样的方法的。



6.请你简述HashMap和Hashtable的区别？

	1、HashMap继承AbstractMap类。
      Hashtable继承了Dictionary类。


	2、HashMap允许有null的键和值。
      Hashtable不允许有null的键和值。
      
	3、Hashtable的方法是synchronized的，HashMap不是。
      Hashtable是线程安全的，HashMap是非线程安全的。

	4、HashMap有containsvValue和containsKey方法。
      Hashtable有contains方法。
    

五、编码题
1.使用List和Map存放多个图书信息，遍历并输出。其中商品属性：编号，名称，单价，出版社；使用商品编号作为Map中的key。

public class Book {
    private String id;
    private String name;
    private int price;
    private String publish;

    public Book(){
    }

    public Book(String id, String name, int price, String publish) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.publish = publish;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getPublish() {
        return publish;
    }

    public void setPublish(String publish) {
        this.publish = publish;
    }

    @Override
    public String toString() {
        return "Book{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", price=" + price +
                ", publish='" + publish + '\'' +
                '}';
    }
}

public class Booktest {
    public static void main(String[] args) {
        Book book1=new Book("123","父与子",34,"南京大学出版社");
        Book book2=new Book("345","安娜卡列尼娜",32,"清华大学出版社");
        Book book3=new Book("347","寓言故事",34,"西安大学出版社");
        Book book4=new Book("456","笑话大全",34,"出版社");

        //list存放图书
        ArrayList<Book> arrayList=new ArrayList<>();
        arrayList.add(book1);
        arrayList.add(book2);
        arrayList.add(book3);
        arrayList.add(book4);
        System.out.println(arrayList);

        Map<String,Book> map=new HashMap<>();
        for(Book b:arrayList){
            map.put(b.getId(),b);
        }
        System.out.println(map);

    }
}

2.使用HashSet和TreeSet存储多个商品信息，遍历并输出；其中商品属性：编号，名称，单价，出版社；要求向其中添加多个相同的商品，验证集合中元素的唯一性。
提示：向HashSet中添加自定义类的对象信息，需要重写hashCode和equals( )
向TreeSet中添加自定义类的对象信息，需要实现Comparable接口，指定比较规则
HashSet:

public class HashsetGood {
    private String id;
    private String name;
    private int price;
    private String publish;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getPublish() {
        return publish;
    }

    public HashsetGood(String id, String name, int price, String publish) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.publish = publish;
    }

    @Override
    public String toString() {
        return "HashsetGood{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", price=" + price +
                ", publish='" + publish + '\'' +
                '}';
    }

    public void setPublish(String publish) {
        this.publish = publish;
    }

    public HashsetGood() {
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof HashsetGood)) return false;
        HashsetGood that = (HashsetGood) o;
        return price == that.price &&
                Objects.equals(id, that.id) &&
                Objects.equals(name, that.name) &&
                Objects.equals(publish, that.publish);
    }

    @Override
    public int hashCode() {

        return Objects.hash(id, name, price, publish);
    }
}

public class HashGoodTest {
    public static void main(String[] args) {
        HashsetGood g1=new HashsetGood("123","父与子",34,"南京大学出版社");
        HashsetGood g2=new HashsetGood("345","安娜卡列尼娜",32,"清华大学出版社");
        HashsetGood g3=new HashsetGood("347","寓言故事",34,"西安大学出版社");
        HashsetGood g4=new HashsetGood("456","笑话大全",34,"出版社");
        HashSet<HashsetGood> hashset=new HashSet<>();
        hashset.add(g1);
        hashset.add(g2);
        hashset.add(g3);
        hashset.add(g4);
        System.out.println(hashset);
    }
}

TreeSet:

public class Good implements Comparable<Good>{

    private String id;
    private String name;
    private int price;
    private String publish;

    public Good() {
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getPublish() {
        return publish;
    }

    public void setPublish(String publish) {
        this.publish = publish;
    }

    public Good(String id, String name, int price, String publish) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.publish = publish;
    }

    @Override
    public int compareTo(Good o) {
        int i=this.getPrice()-o.getPrice();
        int j=(i==0)?this.getName().compareTo(o.getName()):i;

        return j;
    }

    @Override
    public String toString() {
        return "Good{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", price=" + price +
                ", publish='" + publish + '\'' +
                '}';
    }
}

public class GoodTest {
    public static void main(String[] args) {
        Good good1=new Good("123","父与子",34,"南京大学出版社");
        Good good2=new Good("345","安娜卡列尼娜",32,"清华大学出版社");
        Good good3=new Good("347","寓言故事",34,"西安大学出版社");
        Good good4=new Good("456","笑话大全",34,"出版社");

        TreeSet<Good> treeSet=new TreeSet<>();

        treeSet.add(good1);
        treeSet.add(good2);
        treeSet.add(good3);
        treeSet.add(good4);

        for(Good good:treeSet){
            System.out.println(good);
            System.out.println("=======================");
        }
    }
}

3.实现List和Map数据的转换。具体要求如下：
功能1：定义方法public void listToMap( ){ }将List中Student元素封装到Map中
1)使用构造方法Student(int id,String name,int age,String sex )创建多个学生信息并加入List
2)遍历List，输出每个Student信息
3)将List中数据放入Map，使用Student的id属性作为key，使用Student对象信息作为value
4)遍历Map，输出每个Entry的key和value
功能2：定义方法public void mapToList( ){ }将Map中Student映射信息封装到List
1)创建实体类StudentEntry，可以存储Map中每个Entry的信息
2)使用构造方法Student(int id,String name,int age,String sex )创建多个学生信息，并使用Student的id属性作为key，存入Map
3)创建List对象，每个元素类型是StudentEntry

public class Student {
    private int id;
    private String name;
    private int age;
    private String sex;

    public Student(int id, String name, int age, String sex) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public Student() {
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

//public Student(int id, String name, int age, String sex)
public class StudentTest {
    public static void main(String[] args) {
        Student s1=new Student(123,"zs",12,"女");
        Student s2=new Student(124,"ls",10,"男");
        Student s3=new Student(122,"sq",18,"女");
        Student s4=new Student(121,"ww",12,"男");

        ArrayList<Student> arrayList=new ArrayList<>();
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);

        System.out.println("存入list");
        for(Student s:arrayList){
            System.out.println(s);
        }
        System.out.println("list转map");
        listToMap(arrayList);

        Map<Integer,Student> map= new HashMap<>();
        map.put(s1.getId(),s1);
        map.put(s2.getId(),s2);
        map.put(s3.getId(),s3);
        map.put(s4.getId(),s4);

        System.out.println("存入map");
        for(Map.Entry<Integer,Student> m:map.entrySet()){
            System.out.println(m.getKey()+"======"+m.getValue());
        }
        System.out.println("转为list");
        MaptoList(map);




    }
    public static void  listToMap(ArrayList<Student> arrayList ){
        Map<Integer,Student> map=new HashMap<>();
        for(Student s:arrayList){
            map.put(s.getId(),s);
        }
        Set<Map.Entry<Integer,Student>> set=map.entrySet();
        for(Map.Entry<Integer,Student>mm:set){
            System.out.println(mm.getKey()+"===="+mm.getValue());

        }

    }
    public static void MaptoList(Map<Integer,Student> map){
        ArrayList<Map.Entry<Integer,Student>> arrayList=new ArrayList<>();
        for(Map.Entry<Integer,Student>mm:map.entrySet()){
            arrayList.add(mm);
        }
        for(Map.Entry<Integer,Student> m:arrayList){
            System.out.println(m);
        }
    }

}

4.统计数组中单词的数量和种类，用Hashamap存放
方法一

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class MapTest {
    public static void main(String[] args) {
        String[] s1 = {"hello", "java", "python", "hello"};
        String[] s2 = {"hello", "java", "python", "hello"};
        String[] s3 = {"java", "hello", "python"};

        ArrayList<String[]> arrayList = new ArrayList<>();
        ArrayList<String> string = new ArrayList<>();
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        int type = 0;


        for (int i = 0; i < arrayList.size(); i++) {
            for (int j = 0; j < arrayList.get(i).length; j++) {
                if (!(string.contains(arrayList.get(i)[j]))) {
                    type++;
                    string.add(arrayList.get(i)[j]);
                }
            }
        }
        System.out.println("type:" + type + ";word:" + string);

        int[] count = new int[type];

        for (int x = 0; x < string.size(); x++) {
            for (int i = 0; i < arrayList.size(); i++) {
                for (int j = 0; j < arrayList.get(i).length; j++) {
                    if (arrayList.get(i)[j].equals(string.get(x))) {
                        count[x]++;
                    }
                }
            }
        }

        HashMap<String, Integer> hashMap = new HashMap<>();

        for (int i = 0; i < string.size(); i++) {
            hashMap.put(string.get(i), count[i]);
        }

        System.out.println(hashMap);

            Set<String> key=hashMap.keySet();
        System.out.println(key);
            for(String s:key){
                Integer c=hashMap.get(s);
                System.out.println(s+"   "+c);
         }
    }
}

方法二：

import java.util.ArrayList;
import java.util.HashMap;

public class MapTest {
    public static void main(String[] args) {
        String[] s1={"hello","java","world","python"};
        String[] s2={"java","hello","world","java"};
        String[] s3={"java","hello","java"};
        ArrayList<String> arrayList=new ArrayList<>();
        Listadd(s1,arrayList);
        Listadd(s2,arrayList);
        Listadd(s3,arrayList);
        System.out.println(arrayList);

        HashMap<String, Integer> map = new HashMap<>();
        for(String string:arrayList){
            map.put(string,0);
        }
        System.out.println(map);

        for(String string1:map.keySet()) {
            for (String string2 : arrayList) {
                if(string1.equals(string2)){
                    map.put(string1,map.get(string1)+1);
                }
            }
        }
    }
    public static void Listadd(String[] s,ArrayList<String> strings){
        for(String string:s){
            strings.add(string);
        }
    }
}

方法三：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;

public class SetTest {
    public static void main(String[] args) {
        String[] s1={"hello","java","world","python"};
        String[] s2={"java","hello","world","java"};
        String[] s3={"java","hello","java"};
        ArrayList<String> arrayList=new ArrayList<>();
        Listadd(s1,arrayList);
        Listadd(s2,arrayList);
        Listadd(s3,arrayList);
        System.out.println(arrayList);

        HashSet<String> set = new HashSet<>();
        for (String s: arrayList) {
            set.add(s);
        }

        System.out.println(set);

        HashMap<String, Integer> map = new HashMap<>();
        for(String string1:set){
            int i=0;
            for(String string2:arrayList){
                if(string1.equals(string2)){
                    i++;
                }
            }
            map.put(string1,i);
        }
        System.out.println(map);


    }

     public static void Listadd(String[] s,ArrayList<String> strings){
        for(String string:s){
            strings.add(string);
        }
     }
}

java入门基础学习（一）
java入门基础学习（二）
java入门基础学习（三）
java入门基础学习（四）
java入门基础学习（五）
java入门基础学习（六）
java入门基础学习（七）
java进阶之常见对象（一）
java进阶之常见对象（二）
java进阶之冒泡排序
java进阶之选择排序
java进阶之面向对象（封装）
java进阶之面向对象（代码块、继承）