目录
什么是集合？
当我们存储一组类型相同的元素的时候，我们应该使用一个容器来存储，数组就是这样一个容器。 但是数组一旦定义，它的长度将不再变化；然而在实际开发中，我们经常需要保存一些长度变化的数据，于是，我们需要一些能够动态增长长度的容器来保存我们的数据。 而我们需要对数据的保存的逻辑可能各种各样，于是就有了各种各样的数据结构。Java中对于各种数据结构的实现，就是我们用到的集合。
集合的体系概述
Java
的集合框架是由很多接口、抽象类、具体类组成的，都位于
java.util
包中。
下图中是常用的几个，Collection，Map，List和Set都是接口，其他是实现类
Collection接口
● Collection
接口－定义了存取一组对象的方法，其子接口
Set
和
List
分别定义了存储方式。
● Set
中的数据对象没有顺序且不可以重复。
● List
中的数据对象有顺序且可以重复。
在
Collection
中定义了一些集合中的共有方法
:
Collection<String> c = new ArrayList<>();
c.add("a");
c.add("b");
c.add("c");
c.add("d");
Collection<String> d = new ArrayList<>();//通过泛型语法为集合设置了一个类型
d.add("a");
d.add("b");
d.add("c");//集合末尾加元素
d.add("d");
c.size();//集合的长度
c.addAll(d);//集合c+d abcdabcd给c
c.clear();//清空集合
d.isEmpty();//判断集合元素个数是否为空
c.remove("a");//删除集合中指定元素 返回值为bollean类型,删除成功返回true
c.retainAll(d);//集合c中保留与集合d中交集的元素 返回值bollean类型，集合c发生变化，返回true
/*c: abcd d: defg c.retainAll(d); c:d 返回true */
Object [] objects = c.toArray();//返回一个包含此集合中所有元素的数组。
String [] strings = c.toArray(new String[0]);
//返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。List 接口及实现类
List继承了Collection接口,有三个实现的类
ArrayList
是应用更加广泛的动态数组实现，它本身不是线程安全的，所以性能要好很多。 ArrayList是可以根据需要调整容量，ArrayList扩容时容量增加150%。与LinkedList：
查询快，增删慢
LinkedList
顾名思义是Java提供的双向链表，所以它不需要像上面两种那样调整容量，它也不是线程安全的。与ArrayList:
查询慢，增删快
Vector
内部是使用对象数组来保存数据，可以根据需要自动的增加容量，当数组已满时，会创建新的数组，并拷贝原有数组数据，它是线程安全的。
ArrayList的常用方法：
ArrayList <String> list = new ArrayList<>();
list.add("ona");
list.add("ona");
list.add("ona");
list.add(0, "onanananana");//向指定位置添加元素
list.remove(0);//删除并返回指定元素
list.get(0);//获取指定位置元素
list.set(0, "ONANANA");//替换指定位置元素
System.out.println(list.size());//返回集合中元素个数LinkedList的常用方法：
LinkedList<String> listL = new LinkedList<>();
listL.add("ona");
listL.add("ona");
listL.add("ona");
listL.add(int index,Object element);//向指定位置添加元素
listL.addFirist(Object element);//添加元素到链表头
listL.addLast(Object element);//添加元素到链表尾
listL.get(int index);//获取指定位置元素
listL.removeFirst();//删除头元素
listL.removeLast();//删除尾元素
System.out.println(listL.remove(1));//删除并返回指定元素
listL.getFirst();//获取头元素
listL.getLast();Set接口
Set接口继承了Collection接口。
Set中所存储的元素是不重复的,但是是无序的, Set中的元素是没有索引的
●
Set接口有两个实现类
●
HashSet
HashSet类中的元素不能重复，即彼此调用equals方法比较，都返回false。
底层数据结构是哈希表+链表
哈希表依赖于哈希值存储
●
TreeSet
可以按照元素的自然顺序排序(c,a,b ---> a,b,c) 添加的元素类型,必须实现排序接口
可以给Set集合中的元素进行指定方式的排序。存储的对象必须实现Comparable接口。
TreeSet底层数据结构是二叉树(红黑树是一种自平衡的二叉树)
Map接口
将键映射到值的对象
一个映射不能包含重复的键
每个键最多只能映射到一个值（值可以重复，键不可以重复）
Map的常用方法
V put(K key,V value)//输入数据到Map
V remove(Object key)//通过键值删除数据
void clear()//清空map
boolean containsKey(Object key)//判断有没有相同的键
boolean containsValue(Object value)
boolean isEmpty()//判断空 还有元素返回false
int size()//长度方法
V get(Object key)//通过键获取值
Collection values()//返回此地图中包含的值的Collection视图。
Set keySet()
Set<Map.Entry<K,V>> entrySet()//遍历
HashMap
数组+链表+二叉树（黑红树）
HashMap中元素的key值不能重复， 排列顺序是不固定的,可以存储一个为null的键TreeMap
TreeMap中所有的元素都保持着某种固定的顺序，如果需要得到一个有序的Map就应该使用TreeMap，key值所在类必须实现Comparable接口，适用于按自然顺序或自定义顺序遍历键(key)。
TreeMap根据key值排序，key值需要实现Comparable接口，重写compareTo方法。TreeMap根据compareTo的逻辑，对 key进行排序。
键是红黑树结构，可以保证键的排序和唯一性
HashTable实现了同步，不能存储为null的键。
集合的遍历/迭代
增强for循环不能删除集合中的元素： 增强for循环本质上是利用迭代器循环，而如果你在循环中删除元素的话，会导致当前迭代器失效。线程安全除外
List接口集合迭代
for循环遍历
增强for循环遍历
迭代器遍历Iderator
List <String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("e");
list.add("e");
list.add("c");
list.add("e");
list.add("e");
/*Iterator 迭代器遍历 返回一个ArryayList中内部类对象，实现Iterator接口，此内部类专门用作
对集合进行遍历时的控制*/
Iterator<String> it = list.iterator();
/*list.removeIf(e -> e.equals("e"));和while代码块作用一样*/
while(it.hasNext())// 判断里面有没有元素 有就会返回TRUE
{
String e =it.next();
if(e.equals("e")){
it.remove();
}
}
System.out.println(list); List <String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("e");
list.add("e");
list.add("c");
list.add("e");
list.add("e");
ListIterator <String> its = list.listIterator(3);//指定位置遍历
while(its.hasNext())
{
String str = its.next();//正序
System.out.println(str);
}
ListIterator <String> it = list.listIterator(list.size());
while(it.hasPrevious())
{
String str1 = it.previous();//逆序
System.out.println(str1);
}Set接口遍历/迭代
增强for循环
迭代器遍历
Map集合遍历
l
方式1：根据键找值
•
获取所有键的集合
•
遍历键的集合，获取到每一个键
•
根据键找值
l
方式2：根据键值对对象找键和值
•
获取所有键值对对象的集合
•
遍历键值对对象的集合，获取到每一个键值对对象
•
根据键值对对象找键和值
Collections类
Collections
是集合类的工具类，与数组的工具类
Arrays
类似
.
addAl l(Col lection<? super T> c, T... elements);
binarySearch(List<? extends Comparable<? super T>> l ist, T key)
sort(List<T> l ist)
sort(List<T> l ist, Comparator<? super T> c)
swap(List<?> l ist, int i, int j)
copy(List<? super T> dest, List<? extends T> src) ;
注意
dest size
需大于等于
src.size
emptyList()
返回为空的集合
,
不能添加数据
fi l l(List<? super T> l ist, T obj)
max(Col lection<? extends T> col l)
min(Col lection<? extends T> col l)
replaceAl l(List<T> l ist, T oldVal, T newVal)
reverse(List<?> l ist)
shuffle(List<?> l ist)
随机排序
copy(dest,src)
集合复制
什么是泛型？为啥要用泛型？
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。
参数化类型，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式，然后在使用/调用时传入具体的类型。
Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，泛型的好处就是在编译的时候能够检查类型安全。
早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题
泛型类
泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。
public class Demo<T>{ / /T可以为任意标识符，常见的如T、E、K、V等形式的参数常用于表示泛型
private T key; / /key这个成员变量的类型为T,T的类型由外部指定
public Demo(T key) { / /泛型构造方法形参key的类型也为T，T的类型由外部指定
this.key = key;
}
public T getKey(){ / /泛型方法getKey的返回值类型为T，T的类型由外部指定
return key;
}
}
传入的实参类型需与泛型的类型参数类型相同，即为Integer.
Demo<Integer> demo = new Demo<Integer>(123456);
1.
泛型的类型参数只能是类类型
2.
泛型的类型参数可以有多个。
3.
如果没有定义具体类型
,
默认为
Object
从泛型类派生子类
子类也是泛型类，子类和父类的泛型类型要一致
class A<T> extends Demo<T>
子类不是泛型类，父类要明确泛型的数据类型
class A extends Demo<String>
泛型接口
泛型接口与泛型类的定义及使用基本相同。
public interface Demo<T> { //定义一个泛型接口 }
子类也是泛型类，子类和父类的泛型类型要一致
class A<T> implements Demo<T>{ }
子类不是泛型类，父类要明确泛型的数据类型
public class A implements Demo<String> { }
泛型通配符
类型通配符一般是使用
"
？
"
代替具体的类型实参。
public void show(Demo<?> obj){ // ?
表示实际传入的参数类型可以是任意的
}
Demo<Integer> gInteger = new Demo<Integer>(123);
Demo<Number> gNumber = new Demo<Number>(456);
show(gInteger);
show(gNumber);
类型通配符上限
类
/
接口
<
？
extends
实参类型
>
要求该泛型的类型，只能是实参类型，或实参类型的子类类型。
类型通配符下限
类
/
接口
<
？
super
实参类型
>
要求该泛型的类型，只能是实参类型，或实参类型的父类类型。
类型擦除
泛型信息只存在于代码编译阶段，在进入 JVM 之前，与泛型相关的信息会被擦除掉，专业术语叫做类型擦除
泛型类被类型擦除后，相应的类型就被替换成 Object 类型或者上限类型
public class Demo<T>{
T name;
public Demo(T name) {
this.name= name;
}
}
Demo是一个泛型类，我们查看它在运行时的状态信息可以通过反射。
Demo<String> demo= new Demo<String>("jim");
Field f = eclz.getField(“name”);
System.out.println(f.getName()+" type:"+f.getType());
name type:java.lang.Object反射：主要是指程序可以访问、检测和修改它本身状态或行为的一种能力
点击这里了解更多知识~~~今天也要涨姿势啦
https://blog.csdn.net/weixin_56800176/article/details/125704034?spm=1001.2014.3001.5501
3624
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
