集合
-
什么是集合
概念
对象的容器,实现了对对象常用的操作
和数组的区别
- 数组可长度固定,集合长度不可固定
- 数组可以存储基本类型和引用类型,集合只能存储引用类型
Collection
-
Collection体系
-
collection父接口
-
特点:代表一组任意类型的对象无序,无下标,不能重复
-
创建集合 和常用方法 遍历
package Collection; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class Demo01 { public static void main(String[] args){ //创建集合 Collection collection=new ArrayList(); //添加元素 collection.add("苹果"); collection.add("西瓜"); collection.add("榴莲"); System.out.println("元素个数:"+collection.size()); collection.remove("榴莲"); //删除元素 // collection.clear();//清空元素 System.out.println(collection); // =========================================== //遍历元素 for(Object object:collection){ System.out.print(object); } System.out.println(); //使用迭代器 //hasNext();判断有木有下一个元素 有返回true //next();获取下一个元素 //remove();删除当前元素 System.out.println("===========迭代器=============="); Iterator it = collection.iterator(); while (it.hasNext()){ System.out.print(it.next()); it.remove();//删除 } //判断 System.out.println("======判断========="); System.out.println(collection.contains("西瓜")); //判断是否存在该元素 如果存在返回true System.out.println(collection.isEmpty()); //判断是否为空 System.out.println(collection.size());// 结果为0 } }
-
-
操作实体类
- 新建一个student类
package Collection; import jdk.nashorn.internal.runtime.regexp.joni.ast.StringNode; public class Student { private String name; private int age; 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 Student(String name, int age) { this.name = name; this.age = age; } public Student() { } }
package Collection; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class Demo02 { public static void main(String[] args) { Collection<Student> collection = new ArrayList(); Student s1 = new Student("zwf", 120); Student s2 = new Student("zwf", 120); Student s3 = new Student("小明", 120); collection.add(s1); collection.add(s2); collection.add(s3); System.out.println(collection.toString()); //前面实体类忘记加toString方法了 输出是地址值 //删除 collection.remove(s1); //遍历 for (Object o:collection) { System.out.println(o.toString()); } //使用迭代器 Iterator<Student> iterator = collection.iterator(); while (iterator.hasNext()){ System.out.println(iterator.next().toString()); } } }
List
- 特点:有序,有下标,元素可以重复
- 看代码不多说
package List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
//特点:有序,有下标,元素可以重复
public class demo01 {
public static void main(String[] args) {
List list=new ArrayList();
list.add("苹果");
list.add("香蕉");
list.add("梨子");
System.out.println("元素个数:"+list.size());
//list.remove(0);
//list.remove("苹果");
System.out.println(list.toString());
//遍历
//1
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
//2
for(Object object:list){
System.out.println(object);
}
//3使用迭代器
Iterator it=list.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
//3.1使用列表迭代器,可以向前或向后遍历,添加,删除,修改
ListIterator it1 = list.listIterator();
System.out.println("----------从前往后-----------");
while (it1.hasNext()){
System.out.println(it1.nextIndex()+":"+it1.next());
}
System.out.println("----------从后往前-----------");
while (it1.hasPrevious()){//这个方法就是把List数组的指针先指向末尾
System.out.println(it1.previousIndex()+":"+it1.previous());
}
//判断
System.out.println(list.contains("苹果"));//判断是否有这个元素
System.out.println(list.isEmpty());//是否为空
//获取位置(下标)
System.out.println(list.indexOf("苹果"));
}
}
关于使用List集合的几个小细节
package List;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class demo02 {
public static void main(String[] args) {
List list =new ArrayList();
//添加数字数据(自动装箱) 就是它会把这个数据包装成Integer引用类型
list.add(20);
list.add(30);
list.add(40);
list.add(250);
//List集合的subList方法: 放回子集合,含头不含尾 就是【1,2,3】 list.subList(0,2)得到集合 list[1,2]
List list1 = list.subList(0, 3);
System.out.println(list1.toString());
/*
*ListIterator逆序遍历时,必须先进行正序遍历,为了将下标(指针)放到元素n后面,从而可以进行逆序遍历
* 或者就在调用list的listIterator方法的时候将list.size()方法作为参数放入
* 例:ListIterator listIterator = list.listIterator( list.size() );
* */
ListIterator listIterator = list.listIterator(list.size());
System.out.println(listIterator.hasNext());//结果为 false
System.out.println(listIterator.hasPrevious());//结果为true 如果参数不加list.size 它俩结果相反
while (listIterator.hasPrevious()){
System.out.println("下标"+listIterator.previousIndex()+"值:"+listIterator.previous());
}
//删除 可以通过下标 或者就是先用integer包装后删除
list.remove(new Integer(20));
list.remove(0);
list.remove((Object)20);//强转为Object也可以
}
}
ArrayList
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XbkQJmhw-1652608134828)(C:\Users\zwf12\AppData\Roaming\Typora\typora-user-images\image-20220330210841336.png)]
-
Student实体类
package ArrayList; import java.util.Objects; public class Student { private String name; private int age; 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 Student(String name, int age) { this.name = name; this.age = age; } public Student() { } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof Student)) return false; Student student = (Student) o; return age == student.age && Objects.equals(name, student.name); } }
-
测试
package ArrayList; import java.util.ArrayList; /* * ArrayList: * 存储结构:数组 查找遍历快,增删改慢 * */ public class demo01 { public static void main(String[] args) { ArrayList<Object> list = new ArrayList<>(); Student s1=new Student("小明",1); Student s2= new Student("小红",2); Student s3= new Student("小花",3); list.add(s1); list.add(s2); list.add(s3); //删除 /*如果要删除小明这个数据,正常情况这样删除是无法删除原来的小明数据因为该方法是通过equals(this==obj)比较的是地址, 所以这里我们要重写equals才能实现 */ list.remove(new Student("小明",1)); System.out.println(list.toString()); System.out.println(list.size()); //循环我就不打了 和上面差不多 //查找 System.out.println(list.indexOf(new Student("小红",2))); //查找该元素下标 如果不存在返回-1 } }
LinkedList
package LinkedList;
import Collection.Student;
import java.util.LinkedList;
import java.util.ListIterator;
/**
* LinkedList的使用
* 存储结构:双向链表
*/
public class demo01 {
public static void main(String[] args) {
LinkedList linkedList=new LinkedList();
//添加元素
Student s1=new Student("小明",1);
Student s2=new Student("小红",2);
Student s3=new Student("小花",31);
linkedList.add(s1);
linkedList.add(s2);
linkedList.add(s3);
System.out.println(linkedList.size());
System.out.println(linkedList.toString());
//删除
linkedList.remove(0);// linkedList.remove(s1); 等价
//遍历
ListIterator listIterator = linkedList.listIterator(linkedList.size());
while (listIterator.hasPrevious()){
System.out.println(listIterator.nextIndex()+":值"+listIterator.previous());
}
}
}
Set
特点
- 无序,无下标,元素不可重复
package Set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class demo01 {
public static void main(String[] args) {
Set<String> set=new HashSet<>();
set.add("小明");
set.add("小红");
set.add("小花");
set.add("小明");//这里会添加不进去,因为set是不可重复的
System.out.println(set.size()); //结果为3
System.out.println(set.toString());
//判断
System.out.println(set.contains("小明"));//true
System.out.println(set.isEmpty());//false
//遍历
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()){
System.out.print(iterator.next());
}
}
}
HashSet
-
基于HashCode计算元素存放位置
-
当存入元素的哈希码相同时,会调用equals进行确定,如结果为true,则拒绝后者存入
package Set;
import Collection.Student;
import java.util.HashSet;
import java.util.Iterator;
/**
* HashSet集合的使用
* 存储结构:哈希表(数组+链表+红黑树)
* 存储过程
* (1)根据hashcode计算存储位置,如果此位置为空,则直接存储,如果不为空执行第二步
* (2)再执行equals方法。如果equals方法为true,则认为是重复,否则,形成链表
*/
public class demo02 {
public static void main(String[] args) {
HashSet<Object> set = new HashSet<>();
Student s1=new Student("小明",1);
Student s2=new Student("小红",2);
Student s3=new Student("小花",3);
set.add(s1);
set.add(s2);
set.add(s3);
set.add(new Student("小明",1));//这里要想它不加进来就需要重写 hashCode,equals
System.out.println("元素个数"+set.size());
Iterator<Object> iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next().toString());
}
}
}
-
重写hashCode和equals
@Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof Student)) return false; Student student = (Student) o; return age == student.age && Objects.equals(name, student.name); } @Override public int hashCode() { return this.name.hashCode()+this.age; }
TreeSet
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yBjS0fXs-1652608134831)(C:\Users\zwf12\AppData\Roaming\Typora\typora-user-images\image-20220331150140898.png)]
Map
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BL43dfKi-1652608134833)(C:\Users\zwf12\AppData\Roaming\Typora\typora-user-images\image-20220331223004231.png)]
package Map;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* Map接口的使用
* 特点: (1)键不能重复,值可以 2,无序
*/
public class demo01 {
public static void main(String[] args) {
//创建Map集合
Map<String,String> map=new HashMap<>();
//添加元素
map.put("cn","中国");
map.put("uk","英国");
map.put("usa","美国");
map.put("cn","zhongguo");//如果键重复会覆盖前面的值
System.out.println("元素个数"+map.size());
System.out.println(map.toString());
//删除
// map.remove("usa");
//遍历key和值
Set<String> s = map.keySet();
for (String key:s) {
System.out.println(key+"------"+map.get(key));
}
//使用entrySet()方法
System.out.println("--------entrySet方法遍历-------");
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String,String> entry:entries){
System.out.println(entry.getKey()+"-----------"+entry.getValue());
}
}
}
HashMap
都差不多不演示了
package Map;
import java.util.HashMap;
public class demo02 {
public static void main(String[] args) {
HashMap<Student, String> map = new HashMap<>();
Student s1=new Student("孙悟空",100);
Student s2=new Student("猪扒就",102);
Student s3=new Student("萨赫尚",103);
map.put(s1,"北京");
map.put(s2,"杭州");
map.put(s3,"上海");
map.put(new Student("萨赫尚",103),"上海1");//重写hashcode和equals就好然后就是覆盖前面的键
System.out.println(map);
System.out.println(map.size());
}
}
Collections工具类
package Map;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class demo03 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(20);
list.add(4);
list.add(54);
list.add(34);
list.add(6);
list.add(60);
//sort排序
System.out.println("排序之前"+list.toString());
Collections.sort(list);
System.out.println("排序之后"+list.toString());//从小到大排序
//binarySrarch 二分查找
int i=Collections.binarySearch(list,4);
System.out.println(i);//打印下标
//copy复制
List<Integer> list1 = new ArrayList<>();
for (i=0;i<list.size();i++){
list1.add(0);
}//因为复制的要求是原数据和要复制的数据长度要相同
Collections.copy(list1,list);
System.out.println(list1);
//反转
Collections.reverse(list);
System.out.println("反转之后"+list.toString());
}
}
list.toString());
Collections.sort(list);
System.out.println(“排序之后”+list.toString());//从小到大排序
//binarySrarch 二分查找
int i=Collections.binarySearch(list,4);
System.out.println(i);//打印下标
//copy复制
List list1 = new ArrayList<>();
for (i=0;i<list.size();i++){
list1.add(0);
}//因为复制的要求是原数据和要复制的数据长度要相同
Collections.copy(list1,list);
System.out.println(list1);
//反转
Collections.reverse(list);
System.out.println(“反转之后”+list.toString());
}
}