集合框架的概述
可以将集合框架作为数组来进行理解
java官方就基于数组,根据不同的数据结构,封装出来了很多的类,这些类统称为:集合框架。
1.List表格
1.1 List表格的特点
用户可以精确控制列表中每个元素的插入位置
用户可以通过列表中的位置访问元素,并搜索列表中的元素
常用的增删改查的方法
可以简单的理解成和数组的使用方式差不多
1.2 ArrayList 创建数组
(1)先调用类
import java.util.ArrayList;
import java.util.List;
(2)创建ArrayList
1.默认容量ArrayList
public static void main(String[] args) {
List list = new ArrayList();
}
2.自定义初始容量List
public static void main(String[] args) {
List list = new ArrayList(6);
}
1.3 ArrayList添加数据
(1) 变量名.add("数据内容")
package com.Text;
import java.util.ArrayList;
import java.util.List;
public class java001 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("java01");
}
(2)变量名.add(数据要添加的下标位置,"数据内容")
package com.Text;
import java.util.ArrayList;
import java.util.List;
public class java001 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("java01");
list.add(3,"java002");
}
1.4 ArrayList删除数据(数据自动向前移位)
(1)删除list中 “数据” #变量名.remove("数据内容")
package com.Text;
import java.util.ArrayList;
import java.util.List;
public class java001 {
public static void main(String[] args) {
List list = new ArrayList();
list.remove("java01");
}
(2)删除特定位置下标内容 #变量名.remove(下标位置)
package com.Text;
import java.util.ArrayList;
import java.util.List;
public class java001 {
public static void main(String[] args) {
List list = new ArrayList();
list.remove(2);
}
(3)删除内容后返回值为删除的结果
package com.Text;
import java.util.ArrayList;
import java.util.List;
public class java001 {
public static void main(String[] args) {
List list = new ArrayList();
boolean remove = list.remove("java01");
}
1.5 ArrayList修改数据
(1)对文件先删除在添加 #变量名.set(下标位置,"修改内容")
package com.Text;
import java.util.ArrayList;
import java.util.List;
public class java001 {
public static void main(String[] args) {
List list = new ArrayList();
list.set(2."java02");
}
1.6 ArrayList查询数据
(1)查询所有的集合数 #int 变量名 = 变量名.size();
package com.Text;
import java.util.ArrayList;
import java.util.List;
public class java001 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("java01");
int size = list.size()
}
(2)get方法查询下标 #Object 变量名 = 变量名.get(下标位置)
package com.Text;
import java.util.ArrayList;
import java.util.List;
public class java001 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("java01");
Object a = list.get(1)
}
(3) 出现的首末位置没有返回-1
首次内容出现的下标位置: int 变量名 = 变量名.indexOf("内容");
最后出现内容的下标位置: int 变量名 = 变量名.lastIndexOf("内容");
(4)for循环和for-each
package com.Text;
import java.util.ArrayList;
import java.util.List;
public class java001 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("java01");
for (int i = 0; i < list.size(); i++) {
Object a1 = list.get(i);
System.out.println(a1);
}
for (Object a2 :list){
System.out.println(a2);
}
}
1.7 ArrayList底层原理
也就是说 ArrayList的底层就是一个 Object 类型的数组 用变量 elementData
2.LinkedList
2.1 LinkedList和ArrayList的区别
ArrayList 底层体现出来的数据结构是 数组
Linkedlist 底层体现出来的数据结构是 链表
2.2 LinkedList的创建
导入包 import java.util.LinkedList;
LinkedList 变量名 = new LinkedList();
package com.Text;
import java.util.LinkedList;
public class java002 {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
}
2.3 Linkedlis的添加
(1) 变量名.add("数据内容")
package com.Text;
import java.util.LinkedList;
public class java002 {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add("张三");
}
(2)变量名.add(数据要添加的下标位置,"数据内容")
package com.Text;
import java.util.LinkedList;
public class java002 {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add(2,"张三");
}
2.4 Linkedlis的删除
(1)删除“数据” #变量名.remove("数据内容")
package com.Text;
import java.util.LinkedList;
public class java002 {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add(2,"张三");
linkedList.remove("张三");
}
(2)删除特定位置下标内容 #变量名.remove(下标位置)
package com.Text;
import java.util.LinkedList;
public class java002 {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add(2,"张三");
linkedList.remove(2);
}
2.5 Linkedlis的修改
(1)对文件先删除在添加 #变量名.set(下标位置,"修改内容")
package com.Text;
import java.util.LinkedList;
public class java002 {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add(2,"张三");
linkedList.set(2,"李四");
}
2.6 Linkedlis的查询
(1)查询所有的链表数 #int 变量名 = 变量名.size();
package com.Text;
import java.util.LinkedList;
public class java002 {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add(2,"张三");
int size = linkedList.size();
}
(2)get方法查询下标 #Object 变量名 = 变量名.get(下标位置)
package com.Text;
import java.util.LinkedList;
public class java002 {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add(2,"张三");
int size = linkedList.size();
}
2.7 Linkedlis的底层原理
当我们创建 LinkedList haha = new LinkedList();
创建了一个对象
由(上一个节点对象类 数据 下一个节点对象类)构成
Set 是无序且不能重复的,是一个结构 (无序:不按照录入顺序排列并且没有下标)
3.HashSet 注意:没有查询
3.1 创建HashSet对象。 默认初始容器大小为(16)70%时 要求扩容
public class Test {
public static void main(String[] args) {
HashSet hashSet= new HashSet();
HashSet hashSet1 = new HashSet(16);//初始容器的大小
}
}
变量名.add("内容")
(1)变量名.add("内容")
(2)变量名.addAll(变量名)
public class Test {
public static void main(String[] args) {
HashSet hashSet= new HashSet();
HashSet hashSet1 = new HashSet(16);//初始容器的大小
hashSet.add("java01");
hashSet.add("java02");
HashSet set2=new HashSet();
set2.add("刘德华");
hashSet.addAll(set2);
}
}
3.2 删除HashSet对象
hashSet.remove("内容");
hashSet.clear();//清空容器集合
public class Test {
public static void main(String[] args) {
HashSet hashSet= new HashSet();
HashSet hashSet1 = new HashSet(16);//初始容器的大小
hashSet.add("java01");
hashSet.add("java02");
hashSet.remove("java01");
hashSet.clear();
}
}
3.3 遍历内容HashSet
(1)通过foreach遍历
(2)通过迭代器来遍历
Iterator iterator = hashSet.iterator();//获取迭代器对象 有序:有下标
while (iterator.hasNext()){//判断是否指定能够移动
Object next = iterator.next();//指定移动并获取当前的元素
public class Test {
public static void main(String[] args) {
HashSet hashSet= new HashSet();
HashSet hashSet1 = new HashSet(16);//初始容器的大小
hashSet.add("java01");
hashSet.add("java02");
for(Object o: hashSet){
System.out.println(o);
}
Iterator iterator = hashSet.iterator();
while (iterator.hasNext()){
Object next = iterator.next();
System.out.println(next);
}
}
}
3.4 HashSet底层内容
public HashSet() {
map = new HashMap<>();
}
在创建一个HashSet的对象时,底层创建的是HashMap。
4.TreeSet集合
TreeSet中的方法和HashSet中的方法一模一样 只是他们的实现不一样。
TreeSet 基于TreeMap 实现。TreeSet可以实现有序集合,但是有序性需要通过比较器实现。
特殊点:存储一个对象类型
public class Test{
public static void main(String[] args) {
TreeSet treeSet=new TreeSet();
treeSet.add(new Student("赵",52));
treeSet.add(new Student("钱",23));
treeSet.add(new Student("孙",68));
treeSet.add(new Student("李",47));
}
}
TreeSet中的元素必须实现Comparable接口 方可放入TreeSet
解决办法有两个:
第一个: 让你的类实现Comparable接口
public class MyComparator implements Comparator {
//需要比对得两个对象
@Override
public int compare(Object o1, Object o2) {
Student s1= (Student) o1;
Student s2= (Student) o2;
if(s1.getAge()>s2.getAge()){
return 1;
}else if(s1.getAge()<s2.getAge()){
return -1;
}else {
return 0;
}
}
}
第二种: 在创建TreeSet时指定排序的对象。
TreeSet treeSet=new TreeSet(); 但是在创建对象时 并没有为其指定排序得规则,那么就要求该集合得元素有排序规则。
如果元素得类已经创建完成,不能修改该类得源码,这时我们又想把该类得对象放入得TreeSet容器中。
这时就需要你在创建TreeSet时指定排序得规则。
public class Demo01 {
public static void main(String[] args) {
//Comparator<? super E> comparator
//为TreeSet容器指定了排序规则
TreeSet treeSet=new TreeSet(new MyComparator());
treeSet.add(new Student(18,"王亚波"));
treeSet.add(new Student(17,"潘世浩"));
treeSet.add(new Student(19,"刘晓东"));
treeSet.add(new Student(19,"娄明阳"));
System.out.println(treeSet);
}
}
5. Map 属于键值对模式
map中得每个元素属于键值对模式。 如果往map中添加元素时 需要添加key 和 value. 它也属于一个接口,该接口常见得实现类有: HashMap.
5.1 如何创建Map对象
默认初始化大小为16 负载因子为0.75
Map map=new HashMap();
Map map2=new HashMap(16);
Map map3=new HashMap(16,0.78f);
5.2 添加操作
1.初始化 Map map=new HashMap();
2.添加操作 变量名.put("关键键",“内容”); //要求map得key必须唯一。
因为key不能重复,所以后者会把前者覆盖
3. 变量名.putAll(变量名); 把变量中的每个元素 添加到map中
4.变量名.putIfAbsent("key",内容) ;//如果指定得key存在,则不放入map中,如果不存在则放入map中
Map map=new HashMap();
map.put("name","赵");
map.put("age",18);
Map a=new HashMap();
m1.put("n1","m1");
m1.put("n2","m2");
map.putAll(a);
map.putIfAbsent("age",28);
5.3 删除操作
map.remove("key");//根据指定得key移除元素
map.clear(); //清空map容器
map.remove("age");
map.clear();
5.4 修改操作
map.replace("name","内容");//替换元素
5.5 查询
1.判断map是否存在指定得key boolean f = map.containsKey("k5");
2.根据指定的key获取对应得value值 Object v = map.get("k5");
3.返回该map中所有得key Set keys = map.keySet();
4.遍历 map. for(Object k:keys){
Object value= map.get(k); System.out.println(k+"==========>"+value);
}
}
boolean f = map.containsKey("k5");//判断map是否存在指定得key
Object v = map.get("k5"); //根据指定的key获取对应得value值
System.out.println(v);
Set keys = map.keySet();//返回该map中所有得key
System.out.println(keys);
//遍历map.
for(Object k:keys){
Object value= map.get(k);//
System.out.println(k+"================>"+value);
}
}
5.6 HashMap的底层原理
JDK1.7 和 JDK1.8他们是有区别得。
JDK1.7使用得数据结构: 数组+链表 而且链表插入模式为头部插入(造成死循环)。
jdk1.8使用得数据结构: 数组+链表+红黑树 而且链表得插入模式为尾部插入。
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
6.泛型
1. 泛型就是限制我们得数据类型。
2.为什么使用泛型?
我们原来在定义集合时,获取元素 需要进行强制类型转换
获取元素时,不方便对元素进行相应得其他操作。
List<类型> list=new ArrayList<类型>();
这里就限制了集合中每个元素得类型。
在获取元素时 默认就是相应得数据类型 而无需在进行转换
package com.Java020;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class Java001 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("java001");
String s = list.get(0);
HashMap<String ,Integer> hashMap= new HashMap<>();
hashMap.put("age",18);
}
在创建泛型类对象时没有指定相应得泛型类型。则默认为Object类型。