Java中的集合框架是指一系列存储数据的接口和类，这些类和接口都位于java.util包中使用集合框架可以解决复杂的数据存储问题，Java中内置了丰富的集合框架，并提供了大量进行处理的方法，用于解决数组中存储数据有限的问题。只能存储引用数据类型数据
List接口：有序集合接口 存储有序集合所有方法
map接口与Collection接口没有关联，因为其特殊的数据存储结构导致不能使用Colleaction接口的方法，只能参照Colleaction接口定义自己的抽象方法并由子类实现
Colleaction接口
List集合接口
可重复有序集合：所有数据存储位置顺序与存入顺序一致（放入顺序与取出顺序相同
底层使用数组进行数据存储
LinkedList：线程不安全
底层使用链表进行数据存储
Vector：线程安全
使用方式图arrayList类似（不常用）
boolean add(E e)
向列表的尾部添加指定的元素（可选操作）。
void add(int index, E element)
在列表的指定位置插入指定元素（可选操作）。
boolean addAll(Collection<? extends E> c)
添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。
boolean addAll(int index, Collection<? extends E> c)
将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
void clear()
从列表中移除所有元素（可选操作）。
boolean contains(Object o)
如果列表包含指定的元素，则返回 true。
boolean containsAll(Collection<?> c)
如果列表包含指定 collection 的所有元素，则返回 true。
boolean equals(Object o)
比较指定的对象与列表是否相等。
E get(int index)
返回列表中指定位置的元素。
int hashCode()
返回列表的哈希码值。
int indexOf(Object o)
返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
boolean isEmpty()
如果列表不包含元素，则返回 true。
Iterator<E> iterator()
返回按适当顺序在列表的元素上进行迭代的迭代器。
E remove(int index)
移除列表中指定位置的元素（可选操作）。
boolean remove(Object o)
从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。
boolean removeAll(Collection<?> c)
从列表中移除指定 collection 中包含的其所有元素（可选操作）。
boolean retainAll(Collection<?> c)
仅在列表中保留指定 collection 中所包含的元素（可选操作）。
E set(int index, E element)
用指定元素替换列表中指定位置的元素（可选操作）。
int size()
返回列表中的元素数。
List<E> subList(int fromIndex, int toIndex)
返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
Object[] toArray()
返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。
ArrayList集合
底层使用数组进行数据的存储的有序集合，存储数据个数随数据增大而增大，所以也被称为有序数组
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
//ArrayList
public class ArrayListTest {
// 底层使用数组作为数据存储有序集合，长度可以随数据增长（动态数组）
public static void main(String[] args) {
// 创建集合对象语法：
// 集合类型<存储数据类型> 变量名=new集合类型<>();
// <E>代表泛型 ，java新特性用于在创建对象时对类中属性进行定义
// 在创建时输入指定数据类型后，所有方法涉及类型都会自动变为指定类型
// 如果创建时没有指定泛型 默认使用Object当做泛型
ArrayList<String> arr = new ArrayList<>();
// add(object)添加方法add及其相应重载方法
// 将数据添加至末尾
arr.add("a");
arr.add("c");// a c
// add(int object)
// 将数据添加至指定索引，原数据依次向后移动
arr.add(1, "b");// a b c
// addAll(collection)
// 将指定集合添加到当前集合末尾处
arr.addAll(arr);// a b c a b c
// addAll(int,collection)
// 将指定集合插入值指定索引原数据依次后移
arr.addAll(1, arr);// a a b c a b c b c a b c
// remove(object) 如果存在删除并返回true(只删除第一个)
boolean remove = arr.remove("D");
// remove(index) 删除指定索引数据 原数据依次向前移动
// 删除并返回删除的数据
String remove2 = arr.remove(0);
//removeAll(collection)
//删除指定集合中所有匹配数据
//如果存在并删除任意一个数据返回true
ArrayList<String> arr2=new ArrayList<>();
arr2.add("d");
arr.removeAll(arr2);
//set(index, object)
//修改方法将指定索引数据修改为指定数据
arr.set(6, "|");
arr.set(7, "|");//a, b, c, a, b, c, |, |, a, b, c
//get(index)
//获取指定索引数据
System.out.println(arr.get(6));
//clear()
//移除所有数据
//arr.clear();
//contains(object)
//是否包含指定数据
System.out.println(arr.contains("-"));
//containsAll(Colletion)
//是否包含指定集合中所有数据
ArrayList<String> arr3=new ArrayList<>();
arr3.add("a");arr3.add("b");arr3.add("d");
System.out.println(arr.containsAll(arr3));
//indexOf(object)
//返回指定数据在集合中第一次出现索引，没有则返回-1
System.out.println(arr.indexOf("d"));
//lastIndexOf(objext)
//返回指定数据在集合中最后一次出现索引，没有则返回-1
System.out.println(arr.lastIndexOf("c"));
//iterator()
//获取当前集合的迭代器
Iterator<String> iterator = arr.iterator();
//使用迭代器遍历集合
while(iterator.hasNext()){//是否存在数据
System.out.print(iterator.next()+" ");//获取数据
}
System.out.println();
//size()
//返回集合中实际存储数据的个数
System.out.println(arr.size());
//arr.subList(int,int)
//返回指定集合起始至结束位置的数据,返回的是一个新的集合
List<String> subList = arr.subList(3, 8);
//toArray()
//将数据以Object数组的形式返回
Object[] array = arr.toArray();
//toArray(数组)
//以自定数组保存返回的数据
String[] a = new String[arr.size()-5];
//创建的数组只是为集合提供强转的对象而不是真正用于存储数据
String[] array2 = arr.toArray(a);
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i]);
}
// toString方法
// 集合中重写的Object的toString 可以直接将所有数据进行输出展示
System.out.println(arr);
}
}linkedList集合
底层以双向链表形式进行数据存储的有序集合
//LinkedList
public class LinkedListTest {
// 底层双向链表存储数据
public static void main(String[] args) {
//与Arraylist一样实现类list接口
//在实现list接口的基础上额外根据本身存储数据形式进行了方法的添加
LinkedList<String> linked=new LinkedList<>();
linked.add("a");linked.add("b");linked.add("c");
//addFirst(object);
//将指定数据添加至起始位置（索引为0）
linked.addFirst("[");
//addLast(object)
//将指定数据添加至末尾位置（当前最大索引+1处）
linked.addLast("]");
//element()
//返回第一个索引位置的数据相当于get(0)
System.out.println(linked.element());
System.out.println(linked);
}
}public class MyLinkedList {
private Data first;// 起始位
private Data last;// 末位
int size = 0;// 存储数据个数
public void add(String str) {
// 使用传入数据创建数据对象
Data data = new Data(str);
if (size == 0) {
// 还没有其他数据本次添加就是第一个数据
first = data;
last = data;
} else {
// 在末尾添加
// 现将原最后一块保存
Data oldLastDate = last;
// 将添加的数据加入原最后一块的后一位属性
oldLastDate.setAfter(data);
// 将原最后一块加入添加块的前一块属性
data.setBefor(oldLastDate);
// 最后将添加块赋值给last
last = data;
}
size++;
}
public String get(int index) {
// 判断是否获取的是起始结束数据
Data d = first;
if (index == 0) {
return first.getData();
} else if (index == size - 1) {
return last.getData();
} else {
// 如果中间数据从第一个依次向下选择
for (int i = 1; i <= index; i++) {
d = d.getAfter();
}
}
return d.getData();
}
// data数据类存储数据
class Data {
private String data;// 存储数据
private Data befor;// 前一块数据
private Data after;// 后一块数据
public Data() {
super();
}
public Data(String data) {
super();
this.data = data;
}
public String getData() {
return data;
}
public void setData(String data) {
this.data = data;
}
public Data getBefor() {
return befor;
}
public void setBefor(Data befor) {
this.befor = befor;
}
public Data getAfter() {
return after;
}
public void setAfter(Data after) {
this.after = after;
}
}
}ArrayList与linkedList的区别
1、存储数据结构的不同
ArrayList底层使用数组进行数据存储，默认存储数据长度为默认创建数组的长度10
LinkedList使用双向链表进行数据存储，无需默认长度数据长度随数据的添加而增长
2、使用场景不同
ArrayList底层使用数组结构，数据按照索引进行一次存储，获取时根据索引可以快速获取指定数据
LinkedList底层使用双向链表，进行数据获取时需要从首位依次查找
当使用查询与修改操作时使用ArrayList
ArrayList底层使用数组结构，数据按照索引进行一次存储，当进行添加与删除操作时之后的原数据需要依次向前向后移动，数据越多移动越多
LinkedList底层使用双向链表，每一位只保存当前数据与前后一位的关联，当进行添加删除操作时只需要修改插入删除位置前后块指向即可
当需要进行添加与删除操作时使用LinkedList
实际上在进行开发过程中使用ArrayList较多
相较于arraylist添加与删除效率而言，linkedList查找修改效率太低，而且之后进行数据存储的是数据库，再从数据库中取出数据后我们会按照末尾依次添加的形式添加到集合中进行保存，之后往往使用查询较多
Set集合接口
不可重复无序集合(存入顺序与取出顺序不同)
可以理解为集合内部中拥有自己的排序方式（数据存储顺序）
只实现了部分list中的方法（list接口中有的方法没有）
HashSet集合
HashSet() 构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。 HashSet(Collection<? extends E> c) 构造一个包含指定 collection 中的元素的新 set。
//hashSet
public class HashSetTest {
public static void main(String[] args) {
//不可重复无序集合->存入顺序与取出顺序可能不同
//底层存储数据使用的是数据的hash值，按照hash值进行排序
HashSet<Integer> set=new HashSet<>();
set.add(23243);set.add(2311);set.add(23);
//在进行添加操作时会先将数据的hash值进行获取，与已有数据进行比较
//如果不存在则添加存在则不进行任何操作
//因为如果出现重复数据hash值相同存放位置能出现问题
//而且在获取时也存在问题
//由于hashcod是无序数组不能使用get获取数据(没有索引)
//只能通过遍历进行输出
//增强for循环
//迭代遍历数据
//语法:for(要遍历的数据类型 变量名：遍历的数据集合){}
//依次取出要遍历数据集合中的数据赋值给中间变量
for (Integer integer : set) {
System.out.print(integer+" " );
}
}
}TreeSet集合
底层使用树形结构进行数据存储
//增强for循环
//迭代遍历数据
//语法:for(要遍历的数据类型 变量名：遍历的数据集合){}
//依次取出要遍历数据集合中的数据赋值给中间变量
for (Integer integer : set) {
System.out.println(integer);
}
int [] arr={1,2,3,34,3,6,54,65,435,35};
for (int i : arr) {
System.out.println(i);
}
ArrayList<Integer> arraylist=new ArrayList<>();
arraylist.add(123);arraylist.add(123);arraylist.add(123);arraylist.add(123);arraylist.add(123);arraylist.add(123);
for(Integer integer:arraylist){
System.out.println(integer);
}for循环与增强for循环的区别
1.语法上的区别
for循环使用初始变量、循环条件、迭代语句控制运行的执行，增强for使用中间变量、迭代数据进行循环的执行
2.获取数据的区别
for循环在循环的过程中使用迭代数据的方法进行数据的获取,增强方法循环使用的是内部判断，是否存在数据
3.循环控制上的区别
for循环可以根据迭代语句动态控制循环的终止与执行，增强for循环只能进行从头到尾的迭代
4.数据操作的区别
for循环使用迭代数据的方法可以在循环中对数据进行修改，增强for循环使用中间变量，数据与存储在迭代数据中的数据没有关联不能修改
练习
自定义实现arraylist集合中所有方法
将集合中重复数据去除只保留一个
使用集合完成登录功能并添加注册
注意：本文归作者所有，未经作者允许，不得转载
