Java基础学习（八）
文章目录
- 一、Collection顶层接口（单列）
- 二、List接口(可重复）
-
- 1.List继承Collection
- 2.ArrayList类
- 3.LinkedList
- 三、Set接口（不可重复）
-
- 1.Set继承Collection
- 2.Hashset实现Set
- 3.TreeSet继承Set
- 4.比较器
-
- 1.Comparator接口，用于对象
- 2.Comparable 接口，用于类
- 四、map接口
- 五、泛型
-
- 1.泛型方法
- 2.泛型类
- 3.泛型接口
- 六、可变参数
- 七、总结
- 八、习题
一、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
- 将键映射到值的对象，不能包含重复的键,每个键可以映射最多一个值,含有重复键会覆盖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集合中的元素都是成对出现,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}
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 map = new HashMap();
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进阶之面向对象（代码块、继承）