文章目录
一、集合概念
- 概念:对象的容器,定义了对多个对象进行操作的常用方法(即实现了对对象常用的操作)。可实现数组的功能。
- 和数组区别:
1>数组长度固定,集合长度不固定
2>数组可以存储基本类型和引用类型,集合只能存储引用类型
1.Collection体系集合
2.Collection父接口
1>特点:代表一组任意类型的对象,无序,五下标,不能重复。
2>方法:
![在这里插入图片描述](https://img-blog.csdnimg.cn/20210118193442270.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjM3MTgxMw==,size_16,color_FFFFFF,t_70)
- 案例演示
import java.util.*;
//Collection接口使用
//1>添加元素
//2>删除元素
//3>遍历元素
//4>判断
public class demo1 {
public static void main(String[] srgs) {
//创建集合
Collection collection = new ArrayList();//父类引用指向子类对象,实现向上转型
//1>添加元素
collection.add("苹果");
collection.add("香蕉");
collection.add("西瓜");
collection.add("西瓜");
System.out.println("元素个数:"+collection.size());
System.out.println(collection);//相当于调用collection.toString();
//2>删除元素
collection.remove("香蕉");
System.out.println("元素个数:"+collection.size());
//3>遍历元素
//遍历的第一种方式使用增强for
for(Object object : collection) {
System.out.println(object);
}
//遍历的第二种方式,使用迭代器
Iterator it = collection.iterator();
//Iterator迭代器共有3个方法:hasNext()[判断是否还有下一个元素]和next()[获取下一个元素]和remove()[删除当前元素]
while(it.hasNext()) {
String s = (String)it.next();//因为next的返回类型是Object类型,所以这一步是进行强制转化
System.out.println(s);
}
//4>判断
//判断是否含含某一个元素
System.out.println(collection.contains("苹果"));
}
}
- 运行结果:
3.List子接口
1>特点:有序、有下标、元素可以重复
2>方法:
3>案例演示
import java.awt.List;
import java.util.*;
public class dem02 {
public static void main(String args[]) {
//创建集合对象
ArrayList list=new ArrayList<>();
//1.添加元素
list.add("小米");
list.add("苹果");
list.add(0,"华为");
System.out.println("元素个数"+list.size());
System.out.println(list.toString());
//2.遍历元素
//增强for
for(Object object : list) {
System.out.println(object);
}
//迭代器
Iterator it = list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
//使用for,因为有角标
for(int i=0;i<list.size();i++) {
System.out.println(list.get(i));//使用角标打印
}
//3.判断
System.out.println(list.contains("华为"));
System.out.println(list.isEmpty());//这是判断是否为空
}
}
结果截图
4>List实现类
ArrayList类(数组结构实现,查询快,增删慢)
Vector类(数组结构实现,查询快,增删慢)
LinkedList类(链表结构实现,查询慢,增删快)
演示Vector集合的使用
import java.util.Vector;
public class dem03 {
public static void main(String[] args) {
//创建集合
Vector vector = new Vector<>();
//1.添加元素
vector.add("苹果");
vector.add("香蕉");
vector.add("黄梨");
vector.add("西红柿");
System.out.println("元素个数:"+vector.size());
//2.删除
vector.remove(0);
vector.remove("苹果");
System.out.println("元素个数:"+vector.size());
//3.遍历
for(int i=0;i<vector.size();i++) {
System.out.println(vector.get(i));
}
}
}
结果截图如下
演示LinkedList
import java.util.LinkedList;
//LinkedList的使用
public class demo04 {
public static void main(String[] args) {
//1.创建LinkedList类的实例
LinkedList linkedlist = new LinkedList<>();
//2.添加元素
linkedlist.add("我是");
linkedlist.add("中国人");
linkedlist.add("我爱");
linkedlist.add("我的");
linkedlist.add("祖国");
//3.遍历
//使用for遍历
for(int i=0;i<linkedlist.size();i++) {
System.out.println(linkedlist.get(i));
}
}
}
效果截图
ArrayList与LinkedList区别
1>从元素存储的结构上区分
ArrayList开辟的是连续的空间
LinkedList开辟的是节点
如下图
二、泛型
二-一、基本知识
1.什么是泛型?
答:泛型其本质是参数化类型,把类型作为参数传递。
2.常见形式有哪些?
答:泛型类,泛型方法,泛型接口。
3.语法是怎么样的呢?
答:<T,……>T称为一种类型占位符,是一种引用类型。
4.使用泛型的好处?
答:
1>提高代码的重用性。
2>防止类型转换异常,提高代码的安全性。
二-二、案例演示(泛型类、泛型方法、泛型接口)
1.泛型类
//myGen.java创建myGen<T>泛型类
/*
* 泛型类
* 语法:类名<T,……>
* T是类型占位符,表示一种引用类型,如果使用多个使用逗号隔开
* 注意:
* 1.泛型只能使用引用类型
* 2.不同的泛型对象之间不能相互赋值
**/
public class myGen<T> {
//使用泛型T
//1.创建变量
T t;
//2.泛型作为方法的参数
public void show(T t) {
//T t = new T();注意:这是一个错误写法,因为T表示一种泛型,我们不知道T的构造函数,也不知道T是否是final修饰,因此只能创建变量,不能实例化
System.out.println(t);
}
//3.泛型作为方法的返回值
public T getT(T t) {
return t;
}
}
//testGen.java使用泛型类
public class testGen {
public static void main(String[] args) {
//使用泛型类创建对象
myGen<String> mygen = new myGen<String>();
String s=mygen.t="加油、坚持";
mygen.show(s);
String str = mygen.getT(s);
mygen.show(str+"第二次");
//使用Integer类型
myGen<Integer> mygen2 = new myGen<>();
int i=mygen2.t=520;
System.out.println(i);
}
}
结果截图:
2.泛型接口
//myInterface.java声明一个接口
/*
* 泛型接口
* 语法:接口名<T>
* 注意:不能使用泛型来创建静态常量
*
* */
public interface myInterface<T> {
String str="祖国花朵";
T server(T t);
}
//myInterfaceimpl.java接口的实现类
public class myInterfaceimpl implements myInterface<String>{
public String server(String t) {
System.out.println(t);
return t;
}
public static void main(String[] args) {
myInterfaceimpl impl = new myInterfaceimpl();
impl.server("abcd");
}
}
//myInterfaceimpl2.java实现的第二种写法
//实现接口的泛型类的第二种写法:不指定类型
public class myInterfaceimpl2<T> implements myInterface<T> {
@Override
public T server(T t) {
// TODO Auto-generated method stub
System.out.println(t);
return t;
}
public static void main(String[] args) {
myInterfaceimpl2<Integer> impl2 = new myInterfaceimpl2<>();
impl2.server(520);
}
}
结果截图:
3.泛型方法
//mygenMe.java
/*
* 泛型方法
* 语法:<T>返回值类型
*注意调用方法时,类型由传入的数据决定。如传入字符串型数据,则类型即为字符串
*
* */
public class mygenMe {
//泛型方法的创建
public <T> void show(T t) {
System.out.println(t);
}
public static void main(String[] args) {
mygenMe meth = new mygenMe();
meth.show("中国加油");//此时就是字符串类型String
meth.show(123);//此时就是整型int
meth.show(123.4);//此时就是double类型
}
}
效果截图
二-三、泛型集合
1.概念
参数化类型,类型安全的集合,强制集合元素的类型必须一致。
2.特点
编译时即可检查,而非运行时抛出异常
访问时,不必类型转换(装箱)
不同泛型之间引用不能相互赋值,泛型不存在多态
3.Set集合
3.1.Set子接口
特点:无序、无下标、元素不可重复
方法:全部继承自Collection中的方法
3.2.Set实现类
HashSet:
基于HashCode实现元素不重复
当存入元素的哈希码相同时,会调用equals进行确认,如结果为true,则拒绝后者存入。
TreeSet:
基于排列顺序实现元素不重复
案例演示
import java.util.HashSet;
import java.util.Set;
/*
* 测试Set接口的使用
* 特点:无序(即打印元素出来的顺序与添加元素的顺序无关)、没有下标、不能重复
* */
public class setdemo1 {
public static void main(String[] args) {
//1.创建集合
Set<String> s = new HashSet<>();
//2.添加数据
s.add("苹果");
s.add("小米");
s.add("华为");
s.add("三星");
System.out.println(s.size());
System.out.println(s.toString());
//3.遍历
//使用增强for遍历
for(Object object : s) {
System.out.println(object);
}
//4.判断
System.out.println(s.contains("华为"));
System.out.println(s.isEmpty());
}
}
3.3.hashSet类简单使用
import java.util.*;
/*
* HashSet集合的使用
* 存储结构:哈希表(数组+链表+红黑树)
*
* */
public class hashsetdemo1 {
public static void main(String[] args) {
//新建集合
HashSet<String> hashSet=new HashSet<String>();
//1.添加元素
hashSet.add("张三");
hashSet.add("李四");
hashSet.add("王五");
hashSet.add("赵六");
System.out.println("元素个数:"+hashSet.size());
System.out.println(hashSet.toString());
//2.删除元素
hashSet.remove("张三");
System.out.println(hashSet.toString());
//3.遍历
//使用增强for
for(String str : hashSet) {
System.out.println(str);
}
//使用迭代器
Iterator<String> it=hashSet.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
//4.判断
System.out.println(hashSet.contains("李四"));
System.out.println(hashSet.isEmpty());
}
}
效果截图如下
3.4.TreeSet
特点:
基于排序顺序实现元素不重复。
实现了SortedSet接口,对集合元素自动排序。
元素对象的类型必须实现Comparable接口,指定排序规则。
通过ComparaTo方法确定是否为重复元素。
//TreeSetdemo1.java
import java.util.*;
public class TreeSetdemo1 {
public static void main(String[] args) {
//1.创建集合
TreeSet<String> tree = new TreeSet<>();
//2.添加元素
tree.add("abc");
tree.add("xyz");
tree.add("def");
System.out.println("元素个数:"+tree.size());
System.out.println(tree.toString());//[abc, def, xyz]自动排序
//3.遍历
//使用增强for
for(String str : tree) {
System.out.println(str);
}
//使用迭代器
Iterator it = tree.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
//4.判断
System.out.println(tree.contains("abc"));
}
}
//TreeSetdemo1.java打印结果:
//元素个数:3
//[abc, def, xyz]
//abc
//def
//xyz
//abc
//def
//xyz
//true
//TreeSetdemo2.java
import java.util.*;
public class TreeSetdemo2 {
public static void main(String[] args) {
// 1.创建集合
TreeSet<Person> tree2 = new TreeSet<>();
// 2.添加元素
Person p1 = new Person("张三", 20);
Person p2 = new Person("李四", 18);
Person p3 = new Person("王五", 21);
Person p4 = new Person("兆龙", 19);
tree2.add(p1);
tree2.add(p2);
tree2.add(p3);
tree2.add(p4);
System.out.println("元素个数:" + tree2.size());
// 3.遍历
// 使用增强for
for (Person str : tree2) {
System.out.println(str.toString());
}
// 使用迭代器
Iterator<Person> it = tree2.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
class Person implements Comparable<Person> {// 实现 Comparable接口,以便于重写ComparaTo方法,从而定义新的排序规则
private int age;
private String name;
Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String s) {
name = s;
}
public void setAge(int a) {
age = a;
}
public String toString() {
return "["+name+","+age+"]";
}
@Override
public int compareTo(Person o) {// 定义新的排序规则
// TODO Auto-generated method stub
int n1 = this.getAge() - o.getAge();
int n2 = this.getName().compareTo(o.getName());
return n1 == 0 ? n1 : n2;// 先按年龄比较
}
}
//TreeSetdemo2.java打印结果:
//元素个数:4
//[兆龙,19]
//[张三,20]
//[李四,18]
//[王五,21]
//[兆龙,19]
//[张三,20]
//[李四,18]
//[王五,21]
//使用TreeSet集合实现字符串按长度进行排序(输出时,字符串长度小的在前,字符串长度较大的在后面)案例
//
import java.util.Comparator;
import java.util.TreeSet;
public class Treeset_string_sort {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 1.创建集合
TreeSet<String> tree3 = new TreeSet<>(new Comparator<String>() {// 使用匿名内部类的形式实现Comparator接口
@Override
public int compare(String o1, String o2) {// 重写比较规则
// TODO Auto-generated method stub
int n = o1.length() - o2.length();
int n2 = o1.compareTo(o2);// 如果字符串长度一样,则按此原来规则进行
return n == 0 ? n2 : n;
}
});
// 2.添加数据
tree3.add("wwwdwwdw");
tree3.add("sss");
tree3.add("aaa");
tree3.add("wwddd");
tree3.add("wewewee");
System.out.println(tree3.size());
System.out.println(tree3.toString());
}
}
//打印结果:
//5
//[aaa, sss, wwddd, wewewee, wwwdwwdw]
4.Map集合
Map接口的特点:
用于存储任意键值对(key-Value)
其中:键,是无序、无下标、不允许重复(唯一);
值,是无序、无下标、允许重复。
Map接口的实现类:HashMap
Map接口的子接口:SortedMap;
该子接口的实现类:TreeMap
常用方法:
4.1.Map接口的使用
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
* Map接口使用:
* 特点:无序、无下标、键唯一(不重复)、值可以重复
*
* */
public class map_user1 {
public static void main(String[] args) {
//1.创建Map集合
Map<String,String> map = new HashMap<>();
//2.添加元素
map.put("cn", "中国");
map.put("uk","英国");
map.put("us","美国");
System.out.println("元素个数:"+map.size());
System.out.println(map.toString());
//3.删除
map.remove("cn");//以键的方式删除元素;因为键是唯一的
System.out.println("删除之后的元素个数:"+map.size());
//4.遍历
//先调用keySet()方法,将转化为所有键的set集合
Set<String> keyset = map.keySet();
//4-1使用增强for
for(String str : keyset) {
System.out.println(str+"------------>"+map.get(str));//get()方法,通过key获取value
}
//4-2.使用entrySet()方法实现遍历
Set<Map.Entry<String,String>> entryset=map.entrySet();//把<>里的整体Map.Entry<String,String>看作一个集合理解即可
//就是把拿过来的Set集合的数据封装成一个个的Map.Entry键值对类型。而此时我们就要根据getKey()和getValue()方法将其获取相应的值
//使用增强for,注意此时的类型是Map.Entry<String,String>
for(Map.Entry<String,String> trys : entryset) {//Entry就是一个映射对(或者说是键值对)。
System.out.println(trys.getKey()+"-----"+trys.getValue());
}
//5.判断
System.out.println(map.containsKey("us"));//判断其键中是否含有us
System.out.println(map.containsValue("美国"));//判断其值中是否含有“美国”
}
}
程序运行结果
图解上述两种遍历方式:
4.2.HashMap实现类的使用
存储结构:哈希表(数组+链表+红黑树)
import java.util.HashMap;
import java.util.Map;
public class Hashmap_user {
public static void main(String[] args) {
// TODO Auto-generated method stub
//1.创建集合
HashMap<Student,String> hashmap = new HashMap<Student,String>();
//2.添加元素
Student s1 = new Student("张三",101);
Student s2 = new Student("王五",102);
Student s3 = new Student("赵四",103);
Student s4 = new Student("李四",104);
hashmap.put(s1,"一等奖");
hashmap.put(s2,"二等奖");
hashmap.put(s3,"三等奖");
hashmap.put(s4,"优秀奖");
System.out.println("元素个数:"+hashmap.size());
System.out.println(hashmap.toString());
//3.删除元素
hashmap.remove(s1);
System.out.println("删除后的元素个数:"+hashmap.size());
//4.遍历
//使用keySet()方法转化为set集合;get()方法就是根据键获取值cu
for(Student str : hashmap.keySet()) {
System.out.println(str.toString()+"----"+hashmap.get(str));
}
//使用entrySet()方法遍历,将其转化为Map.Entry<Student, String>类型的键值对
for(Map.Entry<Student, String> entry : hashmap.entrySet()) {
System.out.println(entry.getKey()+"---"+entry.getValue()+"第2种");
}
//5.判断
System.out.println(hashmap.containsKey(s1));
System.out.println(hashmap.containsValue("三等奖"));
}
}
class Student{
private String str;
private int num;
Student(String s,int n){
str=s;
num=n;
}
void setStr(String s) {
str=s;
}
void setNum(int n) {
num=n;
}
String getStr() {
return str;
}
int getNum() {
return num;
}
public String toString() {
return str+" "+num;
}
}
程序运行结果截图:
4.3.TreeMap集合
实现了SortedMap接口(是Map的子接口),可以对key自动排序
import java.util.Map;
import java.util.TreeMap;
public class treemap_user {
public static void main(String[] args) {
// TODO Auto-generated method stub
//1.创建集合
TreeMap<Stu,String> treemap = new TreeMap<Stu,String>();
//2.添加元素
Stu t1 = new Stu("张三",101);
Stu t2 = new Stu("王五",102);
Stu t3 = new Stu("赵四",103);
Stu t4 = new Stu("李四",104);
treemap.put(t1,"一等奖");
treemap.put(t2,"二等奖");
treemap.put(t3,"三等奖");
treemap.put(t4,"优秀奖");
System.out.println("元素个数:"+treemap.size());
System.out.println(treemap.toString());
//3.删除元素
treemap.remove(t1);
System.out.println("删除后的元素个数:"+treemap.size());
//4.遍历
//使用keySet()方法转化为set集合;get()方法就是根据键获取值
for(Stu str : treemap.keySet()) {
System.out.println(str.toString()+"----"+treemap.get(str));
}
//使用entrySet()方法遍历,将其转化为Map.Entry<Stu, String>类型的键值对
for(Map.Entry<Stu, String> entry : treemap.entrySet()) {
System.out.println(entry.getKey()+"---"+entry.getValue()+"第2种");
}
//5.判断
System.out.println(treemap.containsKey(t1));
System.out.println(treemap.containsValue("三等奖"));
}
}
class Stu implements Comparable<Stu>{
private String str;
private int num;
Stu(String s,int n){
str=s;
num=n;
}
void setStr(String s) {
str=s;
}
void setNum(int n) {
num=n;
}
String getStr() {
return str;
}
int getNum() {
return num;
}
public String toString() {
return str+" "+num;
}
@Override
public int compareTo(Stu o) {
// TODO Auto-generated method stub
//比学生学号,如果没有这个吧将会报错java.lang.ClassCastException:
int n1 = this.num-o.getNum();
return n1;
}
}
程序运行结果截图
5.Colletions工具类
集合工具类,定义了除了存取以外的集合常用方法(对集合的操作)
常用方法:
import java.util.*;
public class collections_user {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(20);
list.add(2);
list.add(10);
list.add(15);
list.add(30);
//sort排序
System.out.println("排序之前:"+list.toString());
Collections.sort(list);
System.out.println("排序之后:"+list.toString());//[2, 10, 15, 20, 30]
//binarySearch二分查找
int i =Collections.binarySearch(list, 10);//找不到返回任意的负数,找得到就返回该值所在的下标值
System.out.println(i);
//copy复制
//注意:要目标集合的大小与所在源集合的大小相同时才能被复制成功
ArrayList<Integer> dest = new ArrayList<Integer>();//没有添加元素时,改集合大小是0
// System.out.println(dest.size());//0
for(int j = 0;j<list.size();j++) {
//这一步使得该集合的元素大小等于源集合的元素的大小
dest.add(j);
}
Collections.copy(dest, list);//第一个参数为目标集合。第二个参数为源集合
System.out.println(dest.toString());
//reverse反转
Collections.reverse(list);
System.out.println("反转之后:"+list.toString());//[30, 20, 15, 10, 2]
//shuffle打乱
Collections.shuffle(list);
System.out.println("打乱之后:"+list.toString());//打乱之后:[10, 30, 20, 15, 2]
//补充:list转化为数组
Integer[] arr=list.toArray(new Integer[0]);//使用<Integer> Integer[] java.util.ArrayList.toArray(Integer[] a)
System.out.println(arr.length);
System.out.println(Arrays.toString(arr));//[15, 10, 20, 2, 30]和打乱之后的顺序一样
//数组转化成集合
String[] str1 = {"张三","李四","王五","zhaoliu"};
List<String> list2 = Arrays.asList(str1);//注意此时这个集合是一个受限集合,不能添加和删除元素,因为数组的长度是固定的,相当于此时集合的长度已经固定
System.out.println(list2);
//再注意,把基本类型转化为数组时,需要把他的类型改变为包装类
Integer[] in = {20,1,10,3,60,56};//注意此时的Integer不能转变为int
List<Integer> inlist = Arrays.asList(in);
System.out.println(inlist);//[20, 1, 10, 3, 60, 56]
}
}
程序运行结果截图:
6.集合总结
集合的概念:
对象的容器,和数组类似,定义了对多个对象进行操作的常用方法。
List集合:有序、元素可以重复、有下标。(ArrayList、LinkedList、Vector)。
Set集合:无序、无下标、元素不可重复(HashSet、TreeSet)。
Map集合:存储一对数据,无序、无下标、键不可重复,值可重复。(HashMap、HashTable、TreeMap)
collections:集合工具类,定义了除了存取以外的集合常用方法