Java基础入门笔记06——String类和StringBuffer类，Java中的三大集合，Set集合，List集合，Map集合，Collection类

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺

常用——类&&接口

String类和StringBuffer类

• String类不能改变串对象中的内容，每次操作后都产生一个新串
• StringBuffer类可以实现字符串动态改变，对原对象增删改查
• toCharArray（）：将字符串对象转换为字符数组
• length（）：获取字符串的长度

回顾

• length：获取数组长度
• size（）：获取集合内元素的个数

Comparator接口——待补充

equals（）和”==”的区别

equals（）仅判断值是否相等

“==”判断值还要判断引用是否相等

Java的三种集合

都是接口，需要具体类实现

1. 集合类存在于java.util包中，是一个用来存放对象的容器
2. 集合只能存放对象。如果存放int型数据，会自动转换为Integer类的对象存入。（Java中每一种基本类型都有对应的引用类型）
3. 集合中存放的是多个对象的引用，对象本身还是存放在堆内存。
4. 集合可以存放不同数据类型，不限数量的对象。

1.Set集合——无序，不可重复

HashSet类

• HashSet类实现了Set接口，Set接口继承于Collection接口
• 按照Hash算法存储集合元素——方便存取查找

特点：
不保证元素排列顺序，不可重复，不是线程安全的，集合元素可以存null

存储过程：
当HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，从而决定该对象在HashSet中的位置

notes：
如果两个元素的equals（）返回true，但是他们的hashCode（）值返回不一致，则hashSet将会把他们存储在不同的位置。
（这一点与不可重复不冲突，注意理解）

package setStudy1117;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class test01 { 

public static void main(String[] args) { 

Set set = new HashSet();
//添加元素add
set.add(1);
set.add("a");
System.out.println(set);
//删除元素
set.remove(1);
System.out.println(set);
//判断是否包含元素——contains
System.out.println(set.contains(1));
//清空所有元素clear
set.clear();
System.out.println(set);
//遍历集合————————
set.add("a");
set.add("b");
set.add("c");
set.add("d");
System.out.println(set);
// 1.使用迭代器iterator遍历
Iterator iter = set.iterator();  //新建迭代器对象
while(iter.hasNext()){ 
           //如果迭代器中有下一个
System.out.println(iter.next());
}
System.out.println("=============================");
// 2.用增强for来遍历
for (Object obj : set) { 

System.out.println(obj);
}
//获取集合中的元素个数
System.out.println(set.size());
//如何展现Set的不可重复性，目前集合中有abcd四个元素
set.add("a");
System.out.println(set);
//集合内不会新增一个a，且元素个数依旧是4
//集合中可以存null,且要算一个元素，size要+1
set.add(null);
System.out.println(set);
System.out.println(set.size());
}
}

Iterator接口

主要用于遍历Collection集合中的元素，Iterator对象也称作迭代器，Iterator是接口，本身并不能创建对象，如果需要Iterator对象，必须有一个被迭代的集合对象，如 Iterator iter=set.iterator（）；

HashSet集合判断两个对象相等的必要条件：

1. 两个对象通过equals（）返回true
2. 两个对象的hashCode()返回值相等

泛型简介

用于限制集合只能存放一种类型的元素

格式：
HashSet<指定类型> set = new HashSet<指定类型>( );

public class test01 { 

public static void main(String[] args) { 

//集合可以存任何类型的数据，不指定泛型相当于默认泛型为Object
Set set = new HashSet();
set.add("a");
set.add(1);
set.add(true);
set.add("csdn");
System.out.println(set);
//指定泛型为String
HashSet<String> setString = new HashSet<>();
setString.add("ssdasdasd");
// setString.add(123);————————编译就会报错类型不匹配
}

TreeSet类

TreeSet类是SortedSet接口的实现类
TreeSet可以确保集合元素处于排序状态

两种排序方法：

• 自然排序（默认），升序
• 定制排序

使用TreeSet必须保证是放入同样类型的对象，否则可能会进行类型转换异常（用泛型来限制）

import java.util.Set;
import java.util.TreeSet;
public class test02 { 

public static void main(String[] args) { 

Set<Integer> set= new TreeSet<Integer>();
set.add(5);
set.add(2);
set.add(15);
set.add(8);
set.add(99);
//默认自然排序，升序
System.out.println(set);  //输出[2, 5, 8, 15, 99]
//使用迭代器指定类型遍历
Iterator<Integer> iterator = set.iterator();
while(iterator.hasNext()){ 

System.out.println(iterator.next());
}
}
}

如何将自定义的类放入TreeSet，并且按照指定属性排序？

自定义的类需要实现接口Comparator（java.util），实现这个接口的时候，一定要实现它里面的抽象方法compare

package setStudy1117;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class test02 { 

public static void main(String[] args) { 

Person person = new Person("张三",25);
Person person1 = new Person("李四",15);
Person person2 = new Person("王五",55);
Person person3 = new Person("lucy",35);
Person person4 = new Person("caty",11);
Set<Person> set= new TreeSet<Person>(new Person());
set.add(person);
set.add(person1);
set.add(person2);
set.add(person3);
set.add(person4);
for (Person p : set) { 

System.out.println(p.name+": "+p.age);
}
}
}
//建立一个 人 类 实现比较器接口（重写compare方法）
class Person implements Comparator<Person> { 

int age;
String name;
public Person() { 

}
public Person(String name,int age) { 

this.name=name;
this.age = age;
}
//重写compare方法，按照年龄升序
@Override
public int compare(Person o1, Person o2) { 
  //年龄正序
if (o1.age>o2.age){ 

return 1;
}else if (o1.age<o2.age){ 

return -1;
}else return 0;
}
}

运行结果

caty: 11
李四: 15
张三: 25
lucy: 35
王五: 55

【下来了解一下comparator接口的compare（）方法，补充】

2. List——有序，可重复

ArrayList类（线程不安全）

（Vector类基本和ArrayList差不多——线程安全——但已被淘汰，此处不再展开）

• ArrayList类实现了List接口，List接口继承于Collection接口
• List集合中每一个元素都有其对应的顺序索引，默认按元素添加顺序设置元素索引（有点类似数组的下标）
• List集合中添加了一些根据索引来操作集合元素的方法

package setStudy1117;
import java.util.ArrayList;
import java.util.List;
public class test03 { 

public static void main(String[] args) { 

List<String> list = new ArrayList<String>();
list.add("b");
list.add("sadab");
list.add("asdasdasdb");
list.add("ssb");
System.out.println(list);  //输出[b, sadab, asdasdasdb, ssb]
//按照索引访问指定位置的元素
System.out.println(list.get(2));
//可重复性，在已有"b"的情况下还能添加"b"
list.add("b");
list.add("sadab");
System.out.println(list);
//在指定位置插入元素
list.add(1,"f");
System.out.println(list);
//在指定位置插入集合
List<String> list1 = new ArrayList<>();  //新建集合list1
list1.add("123");
list1.add("456");
//在二号位置插入集合list1，插入吼list1会被打散按顺序占多个位置
list.addAll(2,list1);
System.out.println(list);
//获取指定元素在集合中第一次出现的索引下标，找不到返回-1
System.out.println(list.indexOf("aaa"));
//获取指定元素在集合中最后一次出现的索引下标，找不到返回-1
System.out.println(list.lastIndexOf("b"));
//移除指定位置的元素
list.remove(7);
System.out.println(list);
//更改指定位置的元素的值
list.set(0,"bbbbb");
System.out.println(list);
//截取指定位置及其以后的元素形成为一个新的列表
List<String> list2 = list.subList(3,5);
//不包含右边界，新列表长度等于终点减去起点
System.out.println(list2);
//获取集合长度
System.out.println(list.size());
}
}

3. Map接口——具有映射关系

• key，value都可以是任何引用类型的数据（在新建对象时，键和值都应该设置泛型）
• Map中的key不允许重复，通过指定的key能找到唯一的value
• HashMap类用于实现Map接口
• HashMap不保证元素顺序

HashMap类（线程不安全）

（HashTable类基本和HashMap差不多——线程安全——已被淘汰，此处不再展开）

package setStudy1117;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class Test04 { 

public static void main(String[] args) { 

Map<String, Integer> map = new HashMap<String, Integer>();
// HashMap对象的添加方法是put（）
map.put("小明",1);
map.put("小红",551);
map.put("白马",51);
map.put("维系",1);
map.put("扣扣",1);
System.out.println(map);   
//map的输出是大括号{}，且有等号连接键值对
//根据键获取值
System.out.println(map.get("小红"));
//根据键删除元素
map.remove("小红");
System.out.println(map);
//获取长度
System.out.println(map.size());
//查询是否存在某个键或者某个值——contains——返回true或false
System.out.println(map.containsKey("小明"));
System.out.println(map.containsValue(1));
//map集合的遍历：
//方法一
//1.首先获取map集合中的key，形成一个新的集合
Set<String> keys = map.keySet();
//2.然后通过遍历key集合，每次循环，以key查询value然后输出
for (String key : keys) { 

System.out.println("key:"+key+",value:"+map.get(key));
//方法二 
//通过map.entrySet()来遍历
//此处这个方法返回的类型为 Set< Entry <String,Integer> >
Set<Entry<String, Integer>> entries = map.entrySet();
for (Entry<String, Integer> entry : entries) { 
                System.out.println("key:"+entry.getKey()+key+",value:"+entry.getValue());;
}
}
}
}

下来了解Map.entry总结到这里
别人总结的

TreeMap类

• 可根据key对集合内的元素排序——自然排序和定制排序

• 一般使用map集合不会用过于复杂的对象做key

package setStudy1117;
import java.util.Map;
import java.util.TreeMap;
public class Test05 { 

public static void main(String[] args) { 

//TreeMap的自然排序是字典排序————可以理解为ASCII码排序
// 数字在字母前面,大写字母在小写字母前面
Map<Integer, String> map = new TreeMap<>();
map.put(1,"a");
map.put(2,"b");
map.put(5,"c");
map.put(4,"a");
System.out.println(map);
//一般按照key排序，此处key的泛型是Integer所以按照数字升序排序
Map<String, String> map1 = new TreeMap<>();
map1.put("Wangwanh","a");
map1.put("shdjsa","b");
map1.put("bjadksd","c");
map1.put("asdjk","a");
map1.put("15asdjk","a");
System.out.println(map1);
//此处按照字典升序排序
}
}

Collections类

Collections类（操作集合的工具类）主要功能是对Set，List，Map等集合进行处理，比如排序，增删改查，反转，随机打乱

package setStudy1117;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Test06 { 

public static void main(String[] args) { 

List<String> list = new ArrayList<>();
list.add("b");
list.add("cb");
list.add("cab");
list.add("cb");
list.add("a");
list.add("1");
System.out.println(list);
//反转列表元素
Collections.reverse(list);
System.out.println(list);
//随机打乱
Collections.shuffle(list);
System.out.println(list);
//排序
Collections.sort(list);
System.out.println(list);//默认按照字典升序
}
}

sort（list）：按照字典升序

sort（List，Comparator）：
根据比较器对象的比较方法（需要重写）对List集合元素进行排序

notes：

如果要使用sort（List，Comparator），则集合里的元素比如此处是学生对象，那么学生类一定要实现比较器接口（Comparator），这样学生类才能重写compare方法。

package setStudy1117;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
//新建学生类
class Student implements Comparator<Student>{ 

int age;
String name;
public Student(){ 
}
public Student(int age,String name){ 

this.age=age;
this.name=name;
}
//根据年龄升序排列的compare方法
@Override
public int compare(Student o1, Student o2) { 

if(o1.age>o2.age)return 1;
else if(o1.age<o2.age)return -1;
else return 0;
}
public class Test06 { 

public static void main(String[] args) { 

Student s1 = new Student(14,"张三");
Student s2 = new Student(12,"李四");
Student s3 = new Student(16,"王五");
Student s4 = new Student(18,"周周");
List<Student> stus=new ArrayList<>();
stus.add(s1);
stus.add(s2);
stus.add(s3);
stus.add(s4);
//遍历输出集合中的数据
for (Student student : stus) { 

System.out.println(student.name+":"+student.age);
}
System.out.println("========================");
//用Collections来排序———在原集合上排序
Collections.sort(stus,new Student());
for (Student student : stus) { 

System.out.println(student.name+":"+student.age);
}
}
}
}

第一：【下来了解一下Comparator.compare（）】
第二：Collections.sort(stus,new Student());查一下这个方法，对参数进行理解

swap（List，int，int）
将指定list集合中的第i元素，和第j个元素进行交换

Collections.swap(list,0,4);

Object max（Collection）
根据元素的自然顺序，返回给定集合中的最大元素（当然也可返回最小值，max->min）

Collections.max(list);

Object max（Collection , Comparator）：
根据比较器Comparator的方法compare（）返回给定集合中的最大元素（或最小min）

package setStudy1117;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Test06 { 

public static void main(String[] args) { 

Student s1 = new Student(14,"张三");
Student s2 = new Student(12,"李四");
Student s3 = new Student(16,"王五");
Student s4 = new Student(18,"周周");
List<Student> stus=new ArrayList<>();
stus.add(s1);
stus.add(s2);
stus.add(s3);
stus.add(s4);
for (Student student : stus) { 

System.out.println(student.name+":"+student.age);
}
Student stu = Collections.max(stus, new Student());
System.out.println("集合中按照年龄来看最大项是：\n"+stu.name+":"+stu.age);
}
}
class Student implements Comparator<Student>{ 

int age;
String name;
public Student(){ 
}
public Student(int age,String name){ 

this.age=age;
this.name=name;
}
//根据年龄升序排列
@Override
public int compare(Student o1, Student o2) { 

if(o1.age>o2.age)return 1;
else if(o1.age<o2.age)return -1;
else return 0;
}
}

输出结果：

张三:14
李四:12
王五:16
周周:18
集合中按照年龄来看最大项是：
周周:18

int frequency（Collection，Object）：
返回指定集合中指定元素的出现次数

System.out.println(Collection.frequency(list,"a"));

boolean replaceAll(List list, Object oldVal , Object newVal):
使用新值替换List对象里的所有旧值

Collections.replaceAll(list,"a","aa")  //把原来集合中的全部a，替换为aa