Collection的另外一个子类LinkedList&Set集合

Set集合和List集合的区别不大，只是Set不可重复，List可重复
Set无序，List有序
集合只要能实现的功能，Set和List都能实现没只不过是选择哪个做最优解的问题

计算机的内存中，有的是连续的内存空间，比如数组，就是连续的内存空间。除了这些连续的内存空间以外，剩下的内存空间都是以链表的形式存在。

链表又分为单向链表和双向链表：

单向链表：一个单向链表分为一个数据域和一个指针域，指针域里存放的是下一个单向链表的地址

双向链表：一个双向链表分为一个数据域，两个指针域，第一个指针存放的是前一个双向链表的地址，第二个指针域存放的是下一个双向链表的地址

Collection集合的两个子类：ArrayList和LinkedList:

ArrayList的底层是数组，LinkedList的底层是一个链表

那么来区分呢一下数组和集合在进行数据的CURD(增删改查)的时候的优缺点

数组由于是连续的内存空间，有序列号（下标），所以数组在进行数据的查询时速度快于集合，但是正是由于数组的连续空间组织，使得数组再进行数据的增删时慢于集合，集合只需要将链表断开，重连即可

而数组要一位一位的换位置，所以数组的增删要慢于集合。

这也正是底层的结构决定了上层的应用。

队列：就和队伍一样，先进先出。

栈：先进后出，虚拟机里的栈是底端封口的。

 ArrayList<String>  list=new ArrayList<>();  泛型：前边的尖括号里写了泛型的类型，后边的尖括号里就可以不用写了，会自动推断出泛型的类型的（在java1.7版本以后出现的）

关于上一篇的抽象类和接口的向上转型问题，我的想法得到了肯定。

Syso(" ")

Scanner sc =new Scanner(System.in);

只要将sc这个对象创建出来，在作用域里，就可以进行多次的调用。

Iterator it =list.iterator();

it.hasNext();  哈希Next方法，判断这个对象的哈希地址是否为空。

在编译器进行编译的时候，会将整个包都进行编译，　所以这个包下只要有同名的类，就会报错。

泛型的四种常用类型  E:element   T : type   K:key   V:value

不能有静态泛型类，因为虚拟机一运行，就将静态的东西加载到内存中，而泛型是非静态的，泛型要等到创建对象之后才能加载到内存中，所以静态类加载时泛型不具体，不能有静态泛型类。

泛型的好处：只需要写一个方法，任何类型的数据都可以使用，必方法的重载还要方法，代码的重用率高。

泛型的通配符  ？

java.lang包下的所有东西，使用的时候都不需要导包。

静态导入：将java.lang包用static修饰，然后导入  以后在使用System.out.println()  时，写为out.println() 即可。

可变参数： fun();

　　public void fun(int... a) fun(){

}  想给fun方法传递几个参数都可以，当参数列表有很多参数时，可变参数必须放在最后一个，这样才好区分哪些为别的参数，那些为可变参数

Set：Collection集合的另一个子类：

Set和List的区别：

List是有序，可重复的

Set是无序，不可重复的

对于Set的不可重复：相同类型的对象，无论你存储多少个，Set集合只保留一个（自定义对象：针对重写hashCode方法和equals方法，若不重写

hashCode方法和equals方法，Set只能通过地址来判断是否相同，做不到不重复）

加载因子：某集合的容量为16，若它的加载因子为1，则只有当16个元素都存储满了，才会扩容，当加载因子为0.75时，集合容量为100，存储75个

对象，就会扩容

哈希冲突：哈希值计算出的索引位置重复，导致该索引位置已经存储了元素，但是还有元素需要存储在这个索引位置，这叫哈希冲突，也叫哈希碰撞

hasCode方法重写的原理：看元素的哈希值是否相同

hashCode方法未重写前：根据地址返回一个哈希值

Set的存储原理：

首先调用元素对象的hashCode方法，来判断该位置有无元素，若无元素，则直接插入

若有元素，则调用元素对象的equals方法，判断元素对象的值是否相同，若相同，则不插入，若不相同，则链式插入，当达到八个元素时，

使用红黑树进行插入。

LinkedList代码演示

public class LinkedList 类 {
public static void main(String[] args) {
// 创建对象
LinkedList<String> list=new LinkedList<>();
// 添加方法
list.add("1");
list.add("2");
list.add("3");
list.add(1, "4");
System.out.println(list);
}
}

1. day05 课堂笔记
1.1. List 集合
1.1.1. LinkedList
底层 ： 双向链表
特点： 增删操作比 ArrayList 速度快，但是查询慢。可以当做栈或者队列使用。
补充内容 ：
① 队列： 特点 ： 先进先出。
② 栈：特点： 先进后出 。
代码演示：

public class LinkedList 类 {
public static void main(String[] args) {
// 创建对象
LinkedList<String> list=new LinkedList<>();
// 添加方法
list.add("1");
list.add("2");
list.add("3");
list.add(1, "4");
System.out.println(list);
}
}

1.1.2. Vector
( 了解并知道 )
1.Vector ： 它是同步的，用法同 Arraylist, 底层也是可变数组。但是效率低
2. 遍历方式 ： Enumeration
① hasMoreElements 相当于 hashNext
② nextElement 相当于 next
***3. LinkedList 与 Arraylist 、 Vector 分别有什么特点？
相同点 ：有序 ，可重复
不同点：
ArrayList 底层： 可变数组，查询速度快，增删慢。线程不安全
LinkedList 底层：双向链表，增删快，查询速度慢。线程不安全
Vector 底层： 可变数组，线程安全的，效率低。用法同 ArrayList
代码演示：

public class Vector 类 {
public static void main(String[] args) {
// 创建对象与添加元素
Vector<String> v=new Vector<>();
v.add("1");
v.add("2");
v.add("3");
// 遍历
Enumeration<String> el = v.elements();
while(el.hasMoreElements()) {
String ne = el.nextElement();
System.out.println(ne);
}
}
}

2. 泛型
了解
1. 泛型 ： 参数化类型 。 -- 》数据类型可变 --- 》 存储数据类型的值的变量。
① 参数？
2. 泛型的分类：
① 泛型类：在类的声明上加泛型
② 泛型接口 : 在接口上加泛型 , 用法同类。
③ 泛型方法。
1> 广义上，在方法上使用泛型。 ( 不算真正的泛型方法。 )
2> 真正的泛型方法 格式 ：
权限修饰符 修饰符 < 泛型的名称 > 返回值前 方法名称 ( 参数列表 )
3. 注意：
① 泛型在创建对象时，必须要具体指定。如果没带泛型，表示 Object 类型。
② 泛型的名称实质就是标识符，一般用字母表示。其实，泛型的名称没有区别，但是 E T K V 名称的
泛型。
这四种只是名称含义上的区别，用法没区别 ： E ： element 元素 T ： type 类型 K ： key
键 V: value 值
③ 静态方法不能使用类、接口上的泛型，如果需要加泛型，使用泛型方法。
代码演示：

public class 泛型 {
public static void main(String[] args) {
Collection<String> c=new ArrayList<String>();// String E="String"
Collection<Integer> c1=new ArrayList<>();// E="Integer"
// 泛型类 求两个数加法
M<Integer> m=new M();
m.add(10, 16);
M<Double> m1=new M();
m1.add(10.5, 20.3);
// 调用 add 方法 执行 Byte 类型的数据的加法。
M m2=new M();
// 如果需要多个泛型，可以通过 , 隔开。
/*M1<Integer,Double> m3=new M1();
m3.add(10, 12.5);*/
// 泛型方法
M1<Integer> m4=new M1();
m4.add(10, 15.1);
}
}
// 泛型类
class M<E>{
// 求两个数的加法 - 》求两个整数 / 浮点型 / 一个整数和一个浮点型 的加法
// 要求只要是数据类型相同的两个数都可以。
public void add(E a,E b) {
}
/*public void add(double a,double b) {
}*/
}
// 泛型类进阶 ：
class /*M1<E,T>*/M1<E>{
// 一个整数和一个浮点型 的加法 参数可能不一样。
public <T>void add(E a, T b) {
}
public static <M>void fun(M a) {
}
}
// 泛型接口
interface T<T>{
}

2.1. 泛型的细节问题
1. 泛型的好处：
① 提高代码的重用性。
② 进行类型转换
③ 安全性。提高程序的健壮性。
2. 集合中泛型的特点：
① 在 1.7jdk 之后 ，菱形技术
② 可擦除技术。
在 class 文件中不存在，在源文件中存在。
3. 泛型的可传递性：
如果子类要指定泛型，需要具体指定父类的泛型
4. 泛型的通配符： ? 当不知道传递的数据类型是什么时，可以使用通配符表示。
① 通配符的上限限定：
格式 ： ? extends T 表示 T 和它的子类可以使用
② 通配符的下限限定
格式 ： ? super T 表示 T 和它的父类可以使用。
代码演示：
public class 泛型的细节问题 {
public static void main(String[] args) {
// 在 1.6jdk 之前，集合中泛型必须是补全。但是 1.7 之后，对象上的泛型可以根据引用上的数据类型进行推断，省略
不写。
ArrayList<String> list=new ArrayList<String>();
// 在 1.7jdk 之后，菱形技术就是根据类型推断，省略对象上的数据类型
ArrayList<String> list1=new ArrayList<>();
fun2(new ArrayList<String>());
fun2(new ArrayList<Integer>());
}
public static void fun2(ArrayList<?> list) {//Integer Double Person
/*// 执行集合的添加方法
list.add("1");
list.add("2");
// 添加一个字符串 concat
String s = list.get(0);*/
}
}
3. JDK1.5 新特性
1.5jdk ：
① 静态导入：在导包的时候 加入了 static 关键字
② 可变参数：实质是一个参数数组。一般作为最后的参数使用
③ 增强 for 循环
代码演示：
public class JDK1_5 新特性 {
public static void main(String[] args) {
/*out.println("aa");
floor(15.1);*/
fun(10,15);
fun(10,15,17);
}
// 求两个整数的和
public static void fun(int... a) {
//
int sum=0;
for (int i : a) {
sum+=i;
}
System.out.println(sum);
}
}
4. Set 集合
1. 对于自定义元素的 Set 集合的存储，不能保证集合没有重复元素的。如果需要去重复元素，就是根据 Set 集
合存储数据的原理进行去重操作。
2. 存储元素的原理：
① hashCode 与 equals 方法。
***② 对于自定义类来说， HashSet 集合去重，需要重写 hashCode 与 equals 方法。
***③ 存储原理：
1 》 HashSet 集合存储元素时，首先调用元素对象的 hashCode 方法，根据哈希码值计算出该元素在
哈希表中的索引位置。
2 》
a) 如果该位置，没有元素存在，直接存储在该位置。
b) 如果该位置有元素存在，这种现象称为哈希冲突 / 哈希碰撞。该现象发生后，会调用 equals 方
法与该位置的元素进行比较。
i) 如果两个元素相同，不插入。
ii) 如果两个元素不相同，插入，在 1.8jdk 之后，如果长度不超过 8 个，采用链表形式 ，如果
长度超过 8 个，采用红黑树。
代码演示：

public class HashSet 集合存储自定义对象 {
public static void main(String[] args) {
HashSet<Teacher> set=new HashSet<>();
set.add(new Teacher(" 张三 ", 19));
set.add(new Teacher(" 李四 ", 19));
set.add(new Teacher(" 王五 ", 19));
set.add(new Teacher(" 王五 ", 19));
System.out.println(set);
}
}
class Teacher{
String name;
int age;
int age;
public Teacher() {
super();
// TODO Auto-generated constructor stub
}
public Teacher(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Teacher [name=" + name + ", age=" + age + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Teacher other = (Teacher) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
4.1. HashSet 集合遍历方式
1.HashSet 集合遍历方式：
** ① 增强 for
** ② 迭代器 Iterator
( 了解 )③ 转数组 :toArray(T[] a)
代码演示：
public class HashSet 集合的遍历 {
public static void main(String[] args) {
HashSet<String> set=new HashSet<>();
set.add("1");
set.add("2");
set.add("3");
set.add("4");
//① 增强 for
/*for(String s:set) {
System.out.println(s);
}*/
//② 迭代器 Iterator
/*Iterator<String> it = set.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}*/
// ③ 转数组
String[] a=new String[set.size()];
String[] array = set.toArray(a);
// 数组的遍历
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}