Java 集合（基础1）-CSDN博客

本文链接：https://blog.csdn.net/yong1875332184/article/details/125343480

集合类是Java数据结构的实现。Java的集合类是java.util包中的重要内容，它允许以各种方式将元素分组，并定义了各种使这些元素更容易操作的方法。Java集合类是Java将一些基本的和使用频率极高的基础类进行封装和增强后再以一个类的形式提供。集合类是可以往里面保存多个对象的类，存放的是对象，不同的集合类有不同的功能和特点，适合不同的场合，用以解决一些实际问题。——百度百科
在这里插入图片描述

Collection List Set

接口Collection

两个子接口 List Set

多个实现 ArrayList LinkedList Vector类

java.util.Collection;
java.util.List;
java.util.Set;

ArrayList<>

ArrayList<>，可变数组，<>内不写内容，则无泛式进行规范，为Object

public class Lt1 {
//集合与泛型
public static void main(String[] args) {
//接口
Collection co1;

//两个子接口
//List ls1;
//Set se1;

//Collection->List => ArrayList
//List<Object>  
//因为没有使用泛式进行规范，所以是Object类型
List ls1 = new ArrayList();

//添加
ls1.add("ok");
ls1.add(100);
ls1.add(0, "java");
ls1.add("sql");
ls1.add(2, "php");
//修改
ls1.set(3, "qq");

ls1.add(3, "qq");
ls1.add(3, "qq");

for (int i = 0; i < ls1.size(); i++) {
 //ls1.get(),获取集合值
 System.out.printf("List[%d] = %s%n", i, ls1.get(i));

}
//ls1.size()，返回集合大小
System.out.println(ls1.size());
//单个删除
//数字代表下标
ls1.remove("php");
ls1.remove("QQ");
for (Object i : ls1) {
 System.out.println(i);
}

List ls2 = new ArrayList();
ls2.add("qq");

//符合条件的全部删除，需要是一个Collection对象
ls1.removeAll(ls2);

//判断是否包含
System.out.println(ls1.contains("java"));

//返回子串位置
System.out.println("qq所在位置:" + ls1.indexOf("qq"));

for (Object i : ls1) {
 System.out.println(i);
}

//清空
ls1.clear();
//是否是空
System.out.println("是不是空："+ls1.isEmpty());
}
}

在这里插入图片描述

List.of();

java 9之后的新方法,可以直接生成一个list集合，但是不能增加删除修改
List<String> ls = List.of("java","php","mysql","c++");

//此方法生成的ls2集合可以增加删除修改
List<String> ls2 = new ArrayLList(List.of("java","php","mysql","c++"));

LinkedList<>

LinkedList采用链表结构的方式来实现List接口因此在进行Insert和remove动作时效率比ArrayList高

Vector

与ArrayList类似，但是Vector是线程安全的

线程安全：就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。

阅读Vector类的源码容易知道，Vector的方法前面加了synchronized关键字，意思指同步。无论多少线程执行此程序，当一个线程没有执行完的时候，其他线程只有等待。所以它被设计成了线程安全的，但是在效率上并没有ArrayList高效。

List与数组的相互转换

数组转List

Integer[] nums = new Integer[]{10,20,300};
//ls3 是不可以增删改查的list
List<Integer> ls3 = Arrays.asList(nums);
//ls2 是可以增删改查的list
List<Integer> ls2 = new ArrayList<>(Arrays.asList(nums));

List转数组

List<String> ls4 = ls1;
String [] str = new ArrayList<>(List.of("java","php","mysql","c++"));
System.out.println(ls4);
ls4.toArray(str);
for(int i =0;i<str.length;i++){
System.out.println(str[i]);
}

规定泛型

//加上泛型
List<String> ls1 = new ArrayList<>();
List<Integer> ls2 = new ArrayList<>();
ls1.add("qq");
ls1.add("1");
ls1.add("1");
ls1.add("1");
ls1.add("v");
ls1.add("s");
ls1.add("2");
ls1.remove(2);
for (int i = 0; i < ls1.size(); i++) {
System.out.printf("lsi[%d]:%s%n",i,ls1.get(i));
}

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CGxx8NgE-1655516243534)(D:\beiyou\Typora\img\image-20220615105819164.png)]$

自定义类型的泛型

Student类

package list;

public class Student {
private int id;
private String name;
public Student(int id, String name) {
  this.id = id;
  this.name = name;
}
public Student() {

}
public int getId() {
  return id;
}

public void setId(int id) {
  this.id = id;
}

public String getName() {
  return name;
}

public void setName(String name) {
  this.name = name;
}

@Override
public String toString() {
  return "Student{" +
          "id=" + id +
          ", name='" + name + '\'' +
          '}';
}
}

使用Student类作为泛型(泛型必须为对象，不能是基本类型）

List<Student> ls1 = new ArrayList<>();
List<String> ls2 = new ArrayList<>();
ls1.add(new Student(2,"s"));
ls1.add(new Student(1,"a"));
ls1.add(new Student(3,"v"));
for (int i = 0; i < ls1.size(); i++) {
System.out.printf("lsi[%d]:%s%n",i,ls1.get(i));
}

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gRZ9d1s2-1655516243535)(D:\beiyou\Typora\img\image-20220615110001145.png)]$

List排序

数字排序，字符串排序，对象排序（对象中的id或者name排序）

Student类

public class Student {
private int id;
private String name;

public Student(int id, String name) {
      this.id = id;
      this.name = name;
  }
public Student() {

}
public int getId() {
  return id;
}

public void setId(int id) {
  this.id = id;
}

public String getName() {
  return name;
}

public void setName(String name) {
  this.name = name;
}

@Override
public String toString() {
  return "Student{" +
          "id=" + id +
          ", name='" + name + '\'' +
          '}';
}
}

排序

public class Ls5 {
public static void main(String[] args) {
  //排序

  //按数字排序
  numSort();
  //按字母排序
  strSort();

  //按对象排序（对象的属性排序）
  arrSort();

}

static void arrSort() {
  System.out.println("对象排序");
  List<Student> ls = new ArrayList<>();
  List<String> ls2 = new ArrayList<>();
  ls.add(new Student(2, "挨打"));
  ls.add(new Student(13, "个人"));
  ls.add(new Student(5, "哦你继续"));
  ls.add(new Student(51, "怄气我"));
  ls.add(new Student(87, "请问非常"));
  ls.add(new Student(45, "挨打大"));
  for (int i = 0; i < ls.size(); i++) {
      System.out.printf("lsi[%d]:%s%n", i, ls.get(i));
  }
  //按id升序
  Collections.sort(ls, (a, b) -> a.getId() - b.getId());
  System.out.println(ls);

  //按name升序
  Collections.sort(ls, (a, b) -> a.getName().compareTo(b.getName()));
  System.out.println(ls);

  //乱序
  Collections.shuffle(ls);
  System.out.println(ls);

}

static void strSort() {
  System.out.println("字符串排序");
  List<String> ls = new ArrayList<>();
  ls.add("java");
  ls.add("javascript");
  ls.add("c++");
  ls.add("basic");
  ls.add("php");
  ls.add("python");
  ls.add("c");
  ls.add("e");
  System.out.println(ls);

  //字母升序
  Collections.sort(ls);
  System.out.println("字母升序" + ls);

  //字母降序
  Collections.sort(ls, (a, b) -> b.compareTo(a));
  System.out.println("字母降序" + ls);

  //乱序
  Collections.shuffle(ls);
  System.out.println("乱序" + ls);


  //按字母长度排序,长度相同的不改变顺序
  Collections.sort(ls, (a, b) -> a.length() - b.length());
  System.out.println("按字母长度排序" + ls);

}

static void numSort() {
  //数字排序
  System.out.println("数字排序");
  Integer[] in1 = {10, 5, 9, 521, 81, 3, 42, 54};
  List<Integer> ls = new ArrayList<>(Arrays.asList(in1));
  System.out.println(ls);
  //升序
  ls.sort((a, b) -> a - b);
  System.out.println(ls);
  //降序
  ls.sort((a, b) -> b - a);
  System.out.println(ls);

  //乱序
  Collections.shuffle(ls);
  System.out.println(ls);

  //升序
  Collections.sort(ls);
  //降序
  Collections.sort(ls, (a, b) -> b - a);
  System.out.println(ls);
}
}

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cbMHhmZ6-1655516243535)(D:\beiyou\Typora\img\image-20220615162036899.png)]$

Set

set是无序集合，没有下标，重复的内容放不进去

HashSet<>

Set的实现类

因为是无序集合，没有下标，所以有些List有的方法，Set没有

//Set没有的方法,或者是与List的区别,无备注的是没有的，有备注的是区别
list.get();
list.set();
list.sort();
list.indexOf();
list.lastIndexOf();
list.replaceAll();
list.add();//仅有一个参数，不能指定下标
list.addAll();//仅有一个参数，不能指定下标

static void sett() {
Set<String> se = new HashSet<>();
//无序集合,没有下标
//String重复的放不进去，存储唯一对象

se.add("java");
se.add(new String("java"));
se.add("Java");

System.out.println(se);


//对象重复的可以放进去,因为对象的地址不同
Set<Student> st = new HashSet<>();
st.add(new Student(1,"aiusd"));
st.add(new Student(1,"aiusd"));
st.add(new Student(1,"aiusd"));
st.add(new Student(1,"aiusd"));
System.out.println(st.size());
	System.out.println(st);
}

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BMVQsWSR-1655516243536)(D:\beiyou\Typora\img\image-20220615194756707.png)]$

单例模式

1.单例类只能有一个实例（构造方法私有）

2.单例类必须自己创建自己的唯一实例

3.单例类必须给所有其他对象提供这一实例。

public class Lt9 {
private static Lt9 lt = new Lt9();

private Integer  id =  0;
private String name = "";
private Lt9(){

}

public static Lt9 getLt(){
  return lt;
}

public void setId(Integer id) {
  this.id = id;
}

public Integer getId() {
  return id;
}

@Override
public String toString() {
  return "Lt9{" +
          "id=" + id +
          ", name='" + name + '\'' +
          '}';
}

public String getName() {
  return name;
}

public void setName(String name) {
  this.name = name;
}
}

Lt9Dame,因为是一个对象，所有最后ID还是一样的值

public class Lt9Dame {
public static void main(String[] args){
  Lt9 ll1 = Lt9.getLt();
  Lt9 ll2 = Lt9.getLt();
  System.out.println(ll1 == ll2);
  ll1.setId(25);
  ll2.setId(30);
  System.out.println(ll1.getId());
  System.out.println(ll2.getId());
}
}