Java核心类库之（常用API、字符串类、集合类、泛型）

public class Student extends Object{

private String name;

private int age;

public Student() { }

public Student(String name, int age) {

this.name = name;

this.age = 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;

}

//自动生成重写toString()方法；按下Fn+Alt+Insert / 右键 -> generate -> toString -> OK

@Override

public String toString() {

return “Student{” +

“name='” + name + ‘’’ +

“, age=” + age +

‘}’;

}

}

package ceshi;

public class ObjectDemo {

public static void main(String[] args) {

Student s = new Student();

s.setName(“yy”);

s.setAge(20);

System.out.println(s); //ceshi.Student@1b6d3586

System.out.println(s.toString()); //ceshi.Student@1b6d3586

//重写后输出

/*源码

Student{name=‘yy’, age=20}

Student{name=‘yy’, age=20}*/

//选中方法Ctrl+B查看方法源码

/*public void println(Object x) { //1、x = s

String s = String.valueOf(x);

synchronized (this) {

print(s);

newLine();

}

}*/

/*public static String valueOf(Object obj) { //2、obj = x

return (obj == null) ? “null” : obj.toString();

}*/

/*public String toString() { //3、

return getClass().getName() + “@” + Integer.toHexString(hashCode()); //所以重写前才会输出ceshi.Student@1b6d3586

}*/

}

}

2、public boolean equals(Object o)

• 默认是比较两个对象的地址是否相同，相同返回true

• 直接比较两个对象的地址是否完全相同，可以用"=="替代equals

• 所以 equals 存在的意义是为了被子类重写

• 重写快捷键：按下Fn+Alt+Insert -> generate -> equals() and hashCode() -> Template：选择 IntelliJ default -> 三个next > finsh ；然后删除hashCode()方法

package ceshi;

public class Student extends Object{

private String name;

private int age;

public Student() { }

public Student(String name, int age) {

this.name = name;

this.age = 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;

}

//自动生成重写equals()方法

@Override

public boolean equals(Object o) {

if (this == o) return true; //1、比较地址是否相同，如果相同就是同一个对象，直接返回true

//2、先判断参数是否为null；判断连个对象是否来自同一个类；一个满足就返回false

if (o == null || getClass() != o.getClass()) return false;

//向下转型

Student student = (Student) o; //student = s2;

//3、比较年龄是否相同，年龄相同往下走

if (age != student.age) return false;

//比较名字是否相同，s1的name不是null才能取调方法

return name != null ? name.equals(student.name) : student.name == null;

}

}

package ceshi;

public class ObjectDemo {

public static void main(String[] args) {

Student s1 = new Student();

s1.setName(“yy”);

s1.setAge(20);

Student s2 = new Student();

s2.setName(“yy”);

s2.setAge(20);

//比较两个对象内容是否相等

System.out.println(s1.equals(s2)); //重写前：false ； 重写后：true

/*public boolean equals(Object obj) {

//this—s1

//obj—s2

return (this == obj); //重写前==比较的是地址值，不是内容需要重写equals()方法

}*/

}

}

1.4 Objects类

• Objects类是 jdk 1.7 开始之后才有的

• 常用方法

| 方法名 | 说明 |

| — | — |

| public static boolean equals(Object a, Object b) | 比较两个对象内容是否相等 |

| public static boolean isNull(Object obj) | 判断变量是否为 null , 为 null 返回 true |

public class ObjectsDemo {

public static void main(String[] args) {

Student s1 = new Student();

Student s2 = new Student();

System.out.println(s1.equals(s2));

System.out.println(Objects.equals(s1,s2));

// true

// true

//询问s1是否为null，为null返回true

System.out.println(Objects.isNull(s1));

}

}

1.5 Arrays类

• Arrays类包含用于操作数组的各种方法

• 工具类的设计思想

• 构造方法用 private 修饰（防止外界创建对象）

• 成员用 public static 修饰（使用类名来访问）

• 常用方法

| 方法名 | 说明 |

| — | — |

| public static String toString(int[] a) | 返回指定数组的内容的字符串表示形式 |

| public static void sort(int[] a) | 按照数字排序指定的数组 |

• 冒泡排序

package ceshi;

public class ArrayDemo {

public static void main(String[] args) {

int[] arr = {21,56,15,89,62};

System.out.println(“排序前:”+arrayToString(arr)); //排序前:[21, 56, 15, 89, 62]

//冒泡排序

for(int i=0;i<arr.length-1;i++) {

for(int x=0;x< arr.length-1-i;x++) {

if(arr[x] > arr[x+1]) {

//当前一个大于后一个时，双方交换位置

int temp = arr[x];

arr[x] = arr[x+1];

arr[x+1] = temp;

}

}

}

System.out.println(“排序后:”+arrayToString(arr)); //排序后:[15, 21, 56, 62, 89]

}

public static String arrayToString(int[] arr) {

StringBuilder sb = new StringBuilder();

sb.append(“[”);

for(int i=0;i<arr.length;i++) {

if(i==arr.length-1) {

sb.append(arr[i]);

}else {

sb.append(arr[i]).append(", ");

}

}

sb.append(“]”);

String s = sb.toString();

return s;

}

}

• Arrays方法范例

package ceshi;

import java.util.Arrays;

public class ArrayDemo {

public static void main(String[] args) {

int[] arr = {21,56,15,89,62};

//1、public static String toString(int[] a) 返回指定数组的内容的字符串表示形式

System.out.println(“排序前：”+ Arrays.toString(arr)); //排序前：[21, 56, 15, 89, 62]

//2、public static void sort(int[] a) 按照数字排序指定的数组

Arrays.sort(arr);

System.out.println(“排序后：”+Arrays.toString(arr)); //排序后：[15, 21, 56, 62, 89]

}

}

1.6 基本类型包装类

• 将基本数据类型封装成对象的好处在于在对象中定义更多的功能方法操作该数据

• 常用的操作之一：用于基本数据类型与字符串之间的转换

| 基本数据类型 | 包装类 |

| — | — |

| byte | Byte |

| short | Short |

| int | Integer(重点) |

| long | Long |

| float | Float |

| double | Double |

| char | Character(特殊) |

| boolean | Boolean |

1.6.1 Integer类概述和使用

• Integer：包装一个对象中原始类型int的值

• 常用方法

| 方法名 | 说明 |

| — | — |

| public static Integer vlaueOf(int i) | 返回表示指定的int值的 Integer 实例 |

| public static Integer vlaueOf(String s) | 返回一个保存指定的 Integer 对象 String |

public class IntegerDemo {

public static void main(String[] args) {

//1、public static Integer vlaueOf(int i) 返回表示指定的int值的 Integer 实例

Integer i1 = new Integer(100);

System.out.println(i1); //100

//2、public static Integer vlaueOf(String s) 返回一个保存指定的 Integer 对象 String

Integer i2 = new Integer(“100”);

// Integer i2 = new Integer(“abc”); 报错，NumberFormatException

System.out.println(i2); //100

}

}

1.6.2 int 和 String 的相互转换

1、int 转换为 String 类型

public static String valueOf(int i)：返回 int 参数的字符串表示形式。该方法是 String 类中的方法

2、String 转换为 int 类型

public static int parselnt(String s)：将字符串解析为int类型。该方法是 Integer 类中的方法

package ceshi;

public class IntegerDemo {

public static void main(String[] args) {

//int — String

int number = 10;

//1、public static String valueOf (int i)

String s = String.valueOf(number);

System.out.println(s); //10

//String — int

String s1 = “100”;

//2、public static int parseInt(String s)

int i = Integer.parseInt(s1);

System.out.println(i); //100

}

}

1.6.3 案例：字符串中数据排序

package ceshi;

import java.util.Arrays;

public class IntegerTest {

public static void main(String[] args) {

String s = “15 8 45 32 21”;

String[] strArray = s.split(" "); //以空格进行分割符传入数组

/*for(int i=0;i< strArray.length;i++) {

System.out.print(strArray[i]+" "); //15 8 45 32 21

}*/

int[] arr = new int[strArray.length];

for (int i = 0; i < arr.length; i++) {

arr[i] = Integer.parseInt(strArray[i]); //String 类型转换为int类型再赋值

}

Arrays.sort(arr);

StringBuilder sb = new StringBuilder();

for (int i = 0; i < arr.length; i++) {

if (i == arr.length - 1) {

sb.append(arr[i]);

} else {

sb.append(arr[i]).append(", ");

}

}

String s1 = sb.toString();

System.out.println(s1); //8, 15, 21, 32, 45

}

}

1.6.4 自动装箱和拆箱

• 自动装箱: 可以直接把基本数据类型的值或变量赋值给包装类

• 自动拆箱: 可以把包装类的变量直接赋值给基本数据类型

public class PackageClass {

public static void main(String[] args) {

//基本数据类型的值或变量赋值给包装类

Integer i = Integer.valueOf(100); //手动调方法装箱

Integer ii = 100; //默认调用Integer.valueOf(100);

//拆箱

int i1 = ii; //自动拆箱，100

ii +=200; //

System.out.println(ii) //300

//开发中如果是引用类型变量最好先做不为null判断

Integer iii = null;

if(iii != null) {

iii += 300; //NullPointerException

}

}

}

• 注意：在使用包装类的时候，如果是操作最好先判断是否为null；推荐只要是对象，再使用前必须进行不为null判断

1.7 日期类

1.7.1 Date类

• 导包：java.util.Date

• 构造方法

| 方法名 | 说明 |

| — | — |

| public Date() | 创建当前系统的此刻日期时间对象 |

| public Date(long time) | 把时间毫秒值转换成日期对象 |

package ceshi;

import java.util.Date;

public class DateDemo {

public static void main(String[] args) {

//1、public Date()

Date d1 = new Date();

System.out.println(d1); //Tue Jul 06 22:36:15 CST 2021

//2、public Date(long time)

long date = 60;

Date d2 = new Date(date);

System.out.println(d2); //Thu Jan 01 08:00:00 CST 1970

}

}

• 常用方法

| 方法名 | 说明 |

| — | — |

| public long getTime() | 获取日期对象从1970年1月1日00：00：00 到现在的毫秒值 |

| public void setTime(long time) | 设置时间，给的是毫秒值 |

package ceshi;

import java.util.Date;

public class DateDemo {

public static void main(String[] args) {

//1、public long getTime() 获取日期对象从1970年1月1日00：00：00 到现在的毫秒值

Date d = new Date();

System.out.println(d.getTime()); //1625582796041

//2、public void setTime(long time) 设置时间，给的是毫秒值

long time = 10006060;

d.setTime(time);

System.out.println(d); //Thu Jan 01 09:00:00 CST 1970

}

}

1.7.2 SimpleDateFormat类 [ˈsɪmpl]

• 可以对日期格式化和解析

• 日期和时间格式由日期和时间模式字符串指定，在日期和时间模式字符串中,从 ‘A’ 到 ‘Z’ 以及从 ‘a’ 到’z’ 引号的字母被解释为表示日期或时间字符串的组件的模式字母

• 常用的模式字母对应： y—年；M—月；d—日；H—时；m—分；s—秒；E—星期几；a—上午 / 下午

• 构造方法：

| 方法名 | 说明 |

| — | — |

| public SimpleDateFormat() | 使用默认模式和日期模式 |

| public SimpleDateFormat(String pattern) | 指定时间的格式创建简单日期格式化对象 |

• 格式化和解析日期方法

| 方法名 | 说明 |

| — | — |

| public String format(Date date) | 将日期格式化为日期 / 时间字符串 |

| public String format(Object time) | 将时间毫秒格式化为日期 / 时间字符串 |

| public Date parse(String source) [pɑːz] | 从给定的字符串开始解析文本生成日期 |

package ceshi;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

public class SimpleDateFormatDemo {

public static void main(String[] args) throws ParseException {

//格式化 Date》String

Date d = new Date();

//1、 SimpleDateFormat sdf = new SimpleDateFormat(); //无参构造

SimpleDateFormat sdf = new SimpleDateFormat(“yyyy年MM月dd日 HH:mm:ss E a”); //2、带参构造

String s = sdf.format(d);

System.out.println(s); //1、21-7-11 上午10:13 2、2021年07月11日 10:16:00 星期日 上午

//解析 String > date

String s1 = “2020年1月1日 8:25:12”;

SimpleDateFormat sdf1 = new SimpleDateFormat(“yyyy年MM月dd日 HH:mm:ss”);

Date d1 = sdf1.parse(s1); //parse报错了，选中按下Alt+enter，默认选第一个

System.out.println(d1); //Wed Jan 01 08:25:12 CST 2020

}

}

1.7.3 日期工具类

package ceshi;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

/*

工具类

构造方法私有

成员方法静态

*/

public class DateUtils {

private DateUtils() {

}

//时间对象格式化

public static String dateToString(Date date, String format) {

SimpleDateFormat sdf = new SimpleDateFormat(format);

String s = sdf.format(date);

return s;

}

//给定日期字符串解析为时间对象

public static Date stringDate(String s,String formart) throws ParseException {

SimpleDateFormat sdf = new SimpleDateFormat(formart);

Date d = sdf.parse(s);

return d;

}

}

package ceshi;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

public class DateDemo {

public static void main(String[] args) throws ParseException {

Date d = new Date();

String s = DateUtils.dateToString(d, “yyyy年MM月dd日 HH:mm:ss”);

System.out.println(s); //2021年07月07日 20:46:08

String s1 = “2022年12月5日”;

Date d1 = DateUtils.stringDate(s1, “yyyy年MM月dd日”);

System.out.println(d1); //Mon Dec 05 00:00:00 CST 2022

}

}

1.7.4 Calendar日历类

• Calendar 代表了系统此刻日期对应的日历对象

• Calendar 是一个抽象类，不能直接创建对象

• 常用方法

| 方法名 | 说明 |

| — | — |

| public static Calendar getInstance() | 返回一个日历类的对象 |

| public int get(int field) | 返回给定日历的值 |

| public void set(int field,int value) | 修改日历的某个字段信息 |

| public abstract void add(int field,int amount) | 根据日历的规则，将指定的时间量添加或减去给定的日历字段 |

| public final void set(int year,int month,int date) | 设置当前日历年月日 |

package ceshi;

import java.util.Calendar;

public class CalendarDemo {

public static void main(String[] args) {

//1、获取Calendar对象

Calendar c = Calendar.getInstance(); //多态形式

//2、public int get (int field) 根据给的日历字段返回值

/* int year = c.get(Calendar.YEAR);

int month = c.get(Calendar.MONTH) + 1; //从0开始所以加个1

int date = c.get(Calendar.DATE);

System.out.println(year+“年”+month+“月”+date+“日”); //2021年7月7日*/

//3、public void set(int field,int value) 修改日历的某个字段信息

//c.set(Calendar.YEAR,2099);

// System.out.println(rightNow.get(Calendar.YEAR)); //2099

//4、public abstract void add(int field,int amount):根据日历的规则，将指定的时间量添加或减去给定的日历字段

//需求1:三年前

/* c.add(Calendar.YEAR,-3);

int year = c.get(Calendar.YEAR);

System.out.println(year); //2018,减了三年*/

//需求2：十年后，五天前

/*c.add(Calendar.YEAR,10);

c.add(Calendar.DATE,-5);

System.out.println();

int year = c.get(Calendar.YEAR);

int month = c.get(Calendar.MONTH) + 1;

int date = c.get(Calendar.DATE);

System.out.println(year+“年”+month+“月”+date+“日”); //2031年7月2日*/

//5、public final void set(int year,int month,int date)：设置当前日历年月日

c.set(2022,1,1);

int year = c.get(Calendar.YEAR);

int month = c.get(Calendar.MONTH) + 1;

int date = c.get(Calendar.DATE);

System.out.println(year+“年”+month+“月”+date+“日”); //2022年2月1日

}

}

2 String类

---

2.1 String概括

• String 类 在java.lang包下，所以使用的时候不需要导包

• java程序中所有的双引号字符串，都是String这个类的对象

• 特点：字符串不可变，它们的值在创建后不可改变

2.2 String构造方法

| 方法名 | 说明 |

| — | — |

| public String() | 创建一个空字符串对象，不包含任何内容 |

| public String(chas[] chs) | 根据字符数组内容，来创建字符串对象 |

| public String(byte[] bys) | 根据字节数组内容，来创建字符串对象 |

| String s = “abc”; | 直接赋值的方法创建字符串对象，内容就是abc |

• 推荐使用直接赋值的方式

• 案例：

public class Demo{

public static void main(String[] args){

//1.public String() 创建一个空字符串对象，不包含任何内容

String s1 = new String();

System.out.println(“s1:”+s1); //s1:（无内容）

//2.public String(chas[] chs) 根据字符数组内容，来创建字符串对象

char[] chs = {‘a’,‘b’,‘c’};

String s2 = new String(chs);

System.out.println(“s2:”+s2); //s2:abc

//3.public String(byte[] bys) 根据字节数组内容，来创建字符串对象

byte[] bys = {97,98,99}; //对应计算机底层字符

String s3 = new String(bys);

System.out.println(“s3:”+s3); //s3:abc

//4.String s = “abc”; 直接赋值的方法创建字符串对象，内容就是abc

String s4 = “abc”;

System.out.println(“s4:”+s4); //s4:abc

}

}

2.3 String对象的区别

• 1.通过 new 创建字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同

• 2.以 “ ” 方式给出的字符串，只要字符串的序列相同（顺序和大小写），无论在程序中出现多少次，JVM都只会建立一个String对象，并在字符串池维护

• 内存

2.4 常考面试题

• 问题1：

• 问题2：

• 问题3：

• 问题4：

2.5 String字符串比较

• 使用双等号作比较

• 基本类型：比较的是数据值是否相同

• 引用类型：比较的是地址值是否相同

• 字符串是对象，它比较内容是否相同，是通过一个方法来实现的，这个方法叫做: equals()

• 范例：

public class Demo{

public static void main(String[] args){

//构造方法的方式得到对象

char[] chs = {‘a’,‘b’,‘c’};

String s1 = new String(chs);

String s2 = new String(chs);

//直接赋值的方法得到对象

String s3 = “abc”;

String s4 = “abc”;

System.out.println(s1.equals(s2)); //true

System.out.println(s1.equals(s3)); //true

System.out.println(s3.equals(s4)); //true

}

}

2.6 案例

2.6.1 案例：用户登录

import java.util.Scanner;

public class Demo{

public static void main(String[] args){

//1

String username = “YM”;

String password = “123456”;

Scanner sc = new Scanner(System.in);

//4

for(int i=1;i<=3;i++) {

//2

System.out.println(“请输入用户名”);

String name = sc.nextLine();

System.out.println(“请输入密码”);

String pwd = sc.nextLine();

//3

if(name.equals(username)&& pwd.equals(password)) {

System.out.println(“登录成功”);

break;

}else {

if (3-i==0){

System.out.println(“你的账户被锁定”);

}else {

System.out.println(“登陆失败，你还有”+(3-i)+“次机会”);

}

}

}

}

}

2.6.2 案例：遍历字符串

import java.util.Scanner;

public class Demo{

public static void main(String[] args){

Scanner sc = new Scanner(System.in);

System.out.println(“请输入一个字符串”);

String line = sc.nextLine();

for(int i=0;i<line.length();i++) { //length()：获取字符串长度

System.out.println(line.charAt(i));

}

}

}

9.2.6.3 案例：统计字符次数

import java.util.Scanner;

public class Demo{

public static void main(String[] args){

Scanner sc = new Scanner(System.in);

System.out.println(“请输入一个字符”);

String line = sc.nextLine();

int bigCount = 0;

int smallCount = 0;

int numberCount = 0;

//遍历字符串，得到每个字符

for(int i=0;i<line.length();i++) {

char ch = line.charAt(i);

//判断字符类型,统计变量+1

if(ch>=‘A’ && ch<=‘Z’){

bigCount++;

}else if(ch>=‘a’ && ch<=‘z’){

smallCount++;

}else if(ch>=‘0’ && ch<=‘9’){

numberCount++;

}

}

System.out.println(“大写字母：”+bigCount+“个”);

System.out.println(“小写字母：”+smallCount+“个”);

System.out.println(“数字：”+numberCount+“个”);

}

}

2.6.4 案例：字符串拼接

public class Demo {

public static void main(String[] args) {

int[] arr = {1,2,3};

String s = arrayToString(arr);

System.out.println(s); //[1, 2, 3]

}

public static String arrayToString(int[] arr) {

String s = “”;

s += “[”;

for(int i=0;i<arr.length;i++) {

if(i== arr.length-1) {

s += arr[i];

}else {

s += arr[i]+", ";

}

}

s += “]”;

return s;

}

}

2.6.5 案例：字符串反转

import java.util.Scanner;

public class Demo {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println(“请输入一个字符串”);

String line = sc.nextLine(); //abc

String s = myReverse(line);

System.out.println(s); //cba

}

public static String myReverse(String s) {

String ss = “”;

for(int i=s.length()-1;i>=0;i–) {

ss += s.charAt(i);

}

return ss;

}

}

2.6.6 案例：字符串截取

public class Demo {

/*

截取字符串:

String substring(int beginIndex):

从传入的索引位置处向后截取，一直截取到末尾，得到新字符串并返回

String substring(int beginIndex, int endIndex):

从beginIndex索引位置开始截取，截取到endIndex索引位置，得到新字符串并返回(包括头，不包括尾)

*/

public static void main(String[] args){

String s = “itheima”;

String ss = s.substring(2);

System.out.println(ss); //heima

String sss = s.substring(0,2);

System.out.println(sss); //it

}

}

2.6.7 案例：字符串替换

//String replace(CharSequence target,Char Sequense replacement)

// 第一个参数为target(被替换的旧值)内容

// 第二个参数为replacement(替换的新值)进行替换

// 返回新的字符串

import java.util.Scanner

public class Demo{

public static void main(String[] args){

// 1.键盘录入一个字符串

Scanner sc = new Scanner(System.in);

System.out.println(“请输入:”);

String s = sc.nextLine();

// 2.进行敏感提替换

String result = s.replace(“TMD”,“***”);

// 3.输出结果

System.out.println(result);

}

}

3 StringBuilder可变字符串类

---

• StringBuilder是一个可变的字符串类，内容可以改变

3.1 StringBuilder构造方法

• 范例

public class Demo {

public static void main(String[] args) {

//创建空白可改变字符串对象

StringBuilder sb = new StringBuilder();

System.out.println(“sb:”+sb); //sb:

System.out.println(“sb.length():”+sb.length()); //sb.length():0

//根据字符串内容创建对象

StringBuilder sb2 = new StringBuilder(“hello”);

System.out.println(“sb2:”+sb2); //sb2:hello

System.out.println(“sb2.length():”+sb2.length()); //5

}

}

3.2 StringBuilder常用方法

| 方法名 | 说明 |

| — | — |

| public StringBuilder append(任意类型) | 添加数据，并返回对象本身 |

| public StringBuilder reverse() | 返回相反的字符序列 |

| public int length() | 返回长度(字符出现的个数) |

• 范例：

public class Demo {

public static void main(String[] args) {

//创建对象

StringBuilder sb = new StringBuilder();

//1.public StringBuilder append(任意类型) 添加数据，并返回对象本身

// StringBuilder sb2 = sb.append(“java”);

// System.out.println(“sb:”+sb); //sb:java，因为返回的是对象本身所以sb赋值了java

// System.out.println(“sb2:”+sb2); //sb2:java

// System.out.println(sb==sb2); //true

// sb.append(“java”);

// sb.append(“word”);

// sb.append(100);

// System.out.println(“sb:”+sb); //sb:javaword100

//链式编程

sb.append(“java”).append(“word”).append(100);

System.out.println(“sb:”+sb); //sb:javaword100

//2.public StringBuilder reverse() 返回相反的字符序列

sb.reverse();

System.out.println(“sb:”+sb); //sb:001drowavaj

}

}

3.3 StringBuilder 和 String 相互转换

• 1.StringBuilder 转换为 String

| public String toString() | 通过toString()可以把StringBuilder 转换为 String |

| — | — |

• 2.String 转换为 StringBuilder

| public StringBuilder(String s) | 通过构造方法就可以把String 转换为 StringBuilder |

| — | — |

• 范例

public class Demo {

public static void main(String[] args) {

//1.StringBulider 转换为 String

StringBuilder sb = new StringBuilder();

sb.append(“hello”);

//public String toString() 通过toString()可以把StringBuilder 转换为 String

String s = sb.toString();

System.out.println(“s:”+s); //s:hello

//2.String 转换为 StringBulider

String s1 = “hello”;

//public StringBuilder(String s) 通过构造方法就可以把String 转换为 StringBuilder

StringBuilder sb1 = new StringBuilder(s1);

System.out.println(“sb1:”+sb1); //sb1:hello

}

}

3.4 案例

3.4.1 案例1：拼接字符串

public class Demo {

public static void main(String[] args) {

//1

int[] arr = {1,2,3};

String s = arrayToString(arr);

System.out.println(s); //[1, 2, 3]

}

//2,定义方法，拼接字符串

public static String arrayToString(int[] arr) {

//3

StringBuilder sb = new StringBuilder();

sb.append(“[”);

for(int i=0;i< arr.length;i++) {

if(i==arr.length-1){

sb.append(arr[i]);

}else {

sb.append(arr[i]).append(", ");

}

}

sb.append(“]”);

String s= sb.toString();

return s;

}

}

3.4.2 案例2：字符串反转

import java.util.Scanner;

public class Demo {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println(“请输入一个字符串”);

String line = sc.nextLine(); //abc

String s = myReverse(line);

System.out.println(s); //cba

}

public static String myReverse(String s) {

//在方法使用StringBuilder实现字符串反转，并把结果转换为String返回

//String - StringBuilder - reverse() - String

// StringBuilder sb = new StringBuilder(s);

// sb.reverse();

//

// String ss = sb.toString();

// return ss;

//链式编程

return new StringBuilder(s).reverse().toString();

}

}

4 集合结构体系

---

4 集合基础

---

• 集合提供一种存储空间可变的存储模型，存储的数据容量可以改变

• ArrayLis<>:

• 可调整大小的数组实现

• <>：是一种特殊的数据类型，泛型

• 可储存重复元素

• 怎么使用呢

• 在出现E的地方我们使用引用数据类型替换即可

• 举例：ArrayList<String>、ArrayList<Student>

4.1 集合与数组的区别

• 共同点:都是存储数据的容器

• 不同点：数组的容量是固定的，集合的容量是可变的

4.2 ArrayList 构造方法和添加方法

import java.util.ArrayList;

public class Demo {

public static void main(String[] args) {

//创建集合对象

ArrayList array = new ArrayList<>();

System.out.println(array); //[]

//添加到集合末尾

array.add(“hello”);

array.add(“word”);

array.add(“java”);

System.out.println(array); //[hello, word, java]

//指定位置，添加元素

array.add(1,“javase”);

System.out.println(array); //[hello, javase, word, java]

array.add(4,“javaee”);

System.out.println(array); //[hello, javase, word, java, javaee]

array.add(6,“javaweb”);

System.out.println(array); //IndexOutOfBoundsException，不能中间跳一个位置

}

}

4.3 ArrayList 常用方法

| 方法名 | 说明 |

| — | — |

| public boolean remove(Object o) | 删除指定的元素，返回删除是否成功 |

| public E remove(int index) | 删除指定索引处的元素,返回被删除的元素 |

| public E set(int index,E element) | 修改指定索引处的元素，返回被修改的元素 |

| public E get(int index) | 返回指定索引处的元素 |

| public int size() | 返回集合中元素的个数 |

• 范例：

import java.util.ArrayList;

public class Demo {

public static void main(String[] args) {

//创建集合对象

ArrayList array = new ArrayList<>();

System.out.println(array); //[]

//添加到集合末尾

array.add(“hello”);

array.add(“word”);

array.add(“java”);

System.out.println(array); //[hello, word, java]

//1,public boolean remove(Object o) 删除指定的元素，返回删除是否成功

// System.out.println(array.remove(“hello”)); //true; 集合变为[word, java]

// System.out.println(array.remove(“javase”)); //false; 集合变为[hello, word, java]

//2,public E remove(int index) 删除指定索引处的元素,返回被删除的元素

// System.out.println(array.remove(1)); //word,集合变为[hello, java]

//3,public E set(int index,E element) 修改指定索引处的元素，返回被修改的元素

// System.out.println(array.set(1,“javase”)); //word;集合变为[hello, javase, java]

//4,public E get(int index) 返回指定索引处的元素

// System.out.println(array.get(0)); //hello

// System.out.println(array.get(1)); //word

// System.out.println(array.get(2)); //java

//5,public int size() 返回集合中元素的个数

System.out.println(array.size()); //3

}

}

4.4 案例

4.4.1 案例1：存储字符串并遍历

import java.util.ArrayList;

public class Demo {

public static void main(String[] args) {

//创建集合对象

ArrayList array = new ArrayList<>();

//加元素

array.add(“java”);

array.add(“天下”);

array.add(“第一”);

for(int i=0;i<array.size();i++) {

String s = array.get(i);

System.out.print(s+" "); //java 天下 第一

}

}

}

4.4.2 案例2：存储学生对象并遍历

• Student类

package ceshi;

public class Student {

private String name;

private int age;

public Student() {

}

public Student(String name, int age) {

this.name = name;

this.age = 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;

}

}

• 测试类

package ceshi;

import java.util.ArrayList;

public class ArrayListStudent {

public static void main(String[] args) {

//定义集合对象

ArrayList array = new ArrayList();

//创建学生对象

Student stu1 = new Student(“小白”,20);

Student stu2 = new Student(“小明”,21);

Student stu3 = new Student(“小黑”,22);

//添加学生对象到集合中

array.add(stu1);

array.add(stu2);

array.add(stu3);

//遍历集合

for(int i=0;i<array.size();i++) {

Student s = array.get(i);

System.out.println(s.getName()+“,”+s.getAge()); //小白,20

//小明,21

//小黑,22

}

}

}

4.4.3 案例3：存储学生对象并遍历升级版

• 测试类

package ceshi;

import java.util.ArrayList;

import java.util.Scanner;

public class ArrayListStudent {

public static void main(String[] args) {

ArrayList array = new ArrayList();

for(int i=1;i<4;i++) {

addStudent(array); //调三次方法

}

//遍历集合

for(int i=0;i<array.size();i++) {

Student s = array.get(i);

System.out.println(s.getName()+“,”+s.getAge());

}

}

public static void addStudent(ArrayList array) {

Scanner sc = new Scanner(System.in);

System.out.println(“请输入一个名字”);

String name = sc.nextLine();

System.out.println(“请输入一个年龄”);

String age = sc.nextLine();

//创建学生对象，把键盘录入的数据赋值给学生对象的成员变量

Student stu = new Student();

stu.setName(name);

stu.setAge(age);

//往集合里加学生对象

array.add(stu);

}

}

5 Collection集合

---

5.1 Collection集合概述

• 是单列集合的顶层接口，它表示一组对象，这些对象也称Collection元素

• JDK不提供此接口的直接实现，它提供更具体的子接口（Set 和 List）实现

package ceshi;

import java.util.AbstractCollection;

import java.util.ArrayList;

import java.util.Collection;

public class CollectionDemo {

public static void main(String[] args) {

//创建Collection集合对象

Collection c = new ArrayList();

//添加元素

c.add(“hello”);

c.add(“world”);

c.add(“java”);

System.out.println©; //[hello, world, java]

}

}

5.2 Collection集合常用方法（查看所有源码快捷键）

| 方法名 | 说明 |

| — | — |

| public boolean add(E e) | 把给定的元素添加到当前集合中 |

| public boolean remove(E e) | 把给定的对象在当前集合中删除 |

| public void clear() | 清空集合中所有的元素 |

| public boolean contains(Object obj) [kənˈteɪnz] 包括 | 判断当前集合中是否存在指定的对象 |

| public boolean isEmpty() [ˈenpti] | 判断当前集合是否为空 |

| public int size() | 返回集合中元素的个数 |

| public Object[] toArray( ) | 把集合中的元素，储存到数组中 |

• 快捷键：Alt+7 打开源码中所有方法

package ceshi;

import java.util.AbstractCollection;

import java.util.ArrayList;

import java.util.Collection;

public class CollectionDemo {

public static void main(String[] args) {

//创建Collection集合对象

Collection c = new ArrayList();

//1、public boolean add(E e) 把给定的元素添加到当前集合中

c.add(“hello”);

c.add(“hello”);

System.out.println©; //[hello, hello] ;ArrayList可以存储重复元素

//2、public boolean remove(E e) 把给定的对象在当前集合中删除

/*System.out.println(c.remove(“hello”)); //true

System.out.println(c.remove(“java”)); //false

System.out.println©; //[hello]*/

//3、public void clear() 清空集合中所有的元素

/*c.clear();

System.out.println©; //[]*/

//4、public boolean contains(Object obj) 判断当前集合中是否存在指定的对象

/*System.out.println(c.contains(“java”)); //false

System.out.println(c.contains(“hello”)); //true*/

//5、public boolean isEmpty() 判断当前集合是否为空

// System.out.println(c.isEmpty()); //false

//6、public int size() 返回集合中元素的个数

// System.out.println(c.size()); //2

//7、public Object[] toArray( 把集合中的元素，储存到数组中

Object[] arr = c.toArray();

for(int i= 0;i< arr.length;i++) {

System.out.print(arr[i]+“,”); //hello,hello

}

}

}

5.3 Collection集合的遍历

• Collection 集合遍历有三种方法：

• 迭代器

• foreach(增强for循环)

• DK 1.8 开始的新技术 Lambda 表达式(了解)

5.3.1 Iterator['lɪtəreɪtə]迭代器遍历集合

• lterator:迭代器，集合的专用遍历方式

• Iterator<E> iterator():返回此集合中元素的迭代器，通过集合的iterator()方法得到

• 迭代器是通过集合的**iterator()**方法得到的，所以我们说它是依赖于集合而存在的

• Iterator中的常用方法

| 方法名 | 说明 |

| — | — |

| E next() | 获取迭代中的下一个元素 |

| boolean hasNext() | 如果迭代具有更多元素，则返回true |

package ceshi;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

public class IteratorDemo {

public static void main(String[] args) {

Collection c = new ArrayList();

c.add(“java”);

c.add(“天下”);

c.add(“无敌”);

//Iterator iterator():返回此集合中元素的迭代器，通过集合的iterator0方法得到

Iterator it = c.iterator(); //c.iterator();按下Ctrl+alt+v

/*public Iterator iterator() {

return new ArrayList.Itr(); //返回的是实现类的对象

}

private class Itr implements Iterator {…}

*/

//E next()

/*System.out.println(it.next()); //java

System.out.println(it.next());

System.out.println(it.next());

System.out.println(it.next()); //NoSuchElementException：表示请求的元素不存在*/

//boolean hasNext() 如果迭代具有更多元素，则返回true

/*if(it.hasNext()) {

System.out.println(it.next()); //java

}

if(it.hasNext()) {

System.out.println(it.next()); //天下

}

if(it.hasNext()) {

System.out.println(it.next()); //无敌

}

if(it.hasNext()) {

System.out.println(it.next()); //无输出

} */

//while循环改良

while(it.hasNext()) {

String s = it.next();

System.out.println(s); //java

//天下

//无敌

}

}

}

• 案例

package ceshi;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

public class CollectionDemo {

public static void main(String[] args) {

//2、创建Collection集合对象

Collection c = new ArrayList();

//3、创建学生对象

Student s1 = new Student(“y1”, 10);

Student s2 = new Student(“y2”, 20);

Student s3 = new Student(“y3”, 30);

//4、把学生添加到集合

c.add(s1);

c.add(s2);

c.add(s3);

//5、遍历集合

Iterator it = c.iterator(); //必须集合添加完毕后创建迭代器对象

while (it.hasNext()) {

Student s = it.next();

System.out.println(s.getName() + “,” + s.getAge());

/*

y1,10

y2,20

y3,30

*/

}

}

}

5.4 Collections工具类

• 包：java.util.Collections

• Collections 并不属于集合，而是用来操作集合的工具类

• 常用方法（全是静态修饰，用类名调用）

| 方法名 | 说明 |

| — | — |

| public static <T extends Comparable<?super T>> void sort(List list) | 将指定的列表按升序排序 |

| public static void reverse(List<?> list) | 反转指定列表中元素顺序 |

| public static void shuffle(List<?> list) | 使用默认的随机源随机排序指定的列表 |

package ceshi;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

public class MapDemo {

public static void main(String[] args) {

List list = new ArrayList<>();

list.add(30);

list.add(20);

list.add(50);

list.add(10);

list.add(40);

System.out.println(list); //[30, 20, 50, 10, 40]

//1,public static <T extends Comparable<?super T>> void sort(List list) 将指定的列表按升序排序

/*Collections.sort(list);

System.out.println(list); //[10, 20, 30, 40, 50]*/

//2,public static void reverse(List<?> list) 反转指定列表中元素顺序

/*Collections.reverse(list);

System.out.println(list); //[40, 10, 50, 20, 30]*/

//3,public static void shuffle(List<?> list) 使用默认的随机源随机排序指定的列表

Collections.shuffle(list);

System.out.println(list);

//第一次运行[10, 40, 30, 50, 20]

//第二次运行[10, 30, 20, 50, 40]

}

}

6 List集合

---

• List系列集合：添加的元素是有序，可重复，有索引

• ArrayList: 添加的元素是有序，可重复，有索引

• LinkedList: 添加的元素是有序，可重复，有索引

• Vector ：是线程安全的，速度慢，开发中很少使用

6.1 List集合概述和特点

List集合概述

1、有序集合(也称为序列)，用户可以精确控制列表中每个元索的插入位置。用户可以通过整数索引访问元素,并获取列表中的元素

2、与Set集合不同，List集合允许重复的元素

List集合特点

1、有序: 存储和取出的元素顺序一致

2、可重复: 存储的元素可以重复

package ceshi;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

public class ListDemo {

public static void main(String[] args) {

//创建集合对象

List list = new ArrayList<>();

//添加元素

list.add(“java”);

list.add(“天下”);

list.add(“无敌”);

list.add(“java”);

System.out.println(list); //[java, 天下, 无敌, java]

//迭代器遍历

Iterator it = list.iterator();

while(it.hasNext()) {

String s = it.next();

System.out.println(s);

/*java

天下

无敌

java*/

}

}

}

6.2 List集合的特有方法

| 方法名 | 说明 |

| — | — |

| public void add(int index,E element) | 该集合中的指定位置上插入元素 |

| public E remove(int index) | 删除列表中指定位置的元素，返回被删除的元素 |

| public E set(int index,E element) | 修改指定索引的元素，返回被修改的元素 |

| public E get(int index) | 返回集合中指定位置的元素 |

package ceshi;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

public class ListDemo {

public static void main(String[] args) {

//创建集合对象

List list = new ArrayList<>();

//添加元素

list.add(“java”);

list.add(“天下”);

list.add(“无敌”);

list.add(“java”);

System.out.println(list); //[java, 天下, 无敌, java]

//1、public void add(int index,E element) 该集合中的指定位置上插入元素

list.add(1,“javase”);

System.out.println(list); //[java, javase, 天下, 无敌, java]

//2、public E remove(int index) 删除列表中指定位置的元素，返回被删除的元素

System.out.println(list.remove(1)); //javase

System.out.println(list); //[java, 天下, 无敌, java]

//3、public E set(int index,E element) 修改指定索引的元素，返回被修改的元素

System.out.println(list.set(0,“java1”)); //java

System.out.println(list); //[java1, 天下, 无敌, java]

//4、public E get(int index) 返回集合中指定位置的元素

System.out.println(list.get(2)); //无敌

//for循环遍历

for(int i=0;i< list.size();i++) {

//5,public E get(int index) 返回集合中指定位置的元素

String s = list.get(i);

System.out.println(s);

/*java1

天下

无敌

java*/

}

}

}

• 案例

• 测试类

package ceshi;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

public class ListDemo {

public static void main(String[] args) {

//2、创建集合对象

List list = new ArrayList();

//3、创建学生对象

Student s1 = new Student(“y1”,10);

Student s2 = new Student(“y2”,20);

Student s3 = new Student(“y3”,30);

//4、学生对象添加到集合

list.add(s1);

list.add(s2);

list.add(s3);

//5、遍历集合：迭代器方法

Iterator it = list.iterator();

while(it.hasNext()) {

Student s = it.next();

System.out.println(s.getName()+“,”+s.getAge());

/*y1,10

y2,20

y3,30*/

}

//5、遍历集合：for循环

for(int i=0;i<list.size();i++) {

Student ss = list.get(i);

System.out.println(ss.getName()+“,”+ss.getAge());

/*y1,10

y2,20

y3,30*/

}

}

}

6.3 ListIterator迭代器

• Lstlterator:列表迭代器

• 通过List集合的listterator()方法得到，所以说它是List集合特有的迭代器

• 用于允许程序员沿任一方向遍历列表的列表迭代器,在迭代期间修改列表,并获取列表中迭代器的当前位置

• 常用方法

| 方法名 | 说明 |

| — | — |

| list.listIterator() | 得到 listIterator 迭代器 |

| E next() | 返回迭代中的下一个元素 |

| boolean hasNext() | 如果迭代具有更多元素，则返回true |

| E previous() [ˈpriːviəs] | 返回列表中的上一个元素 |

| boolean hasPrevious() | 如果此列表迭代器在相反方向遍历列表时具有更多元索，则返回true |

| void add(E e) | 将指定的元索插入列表 |

package ceshi;

import java.util.ArrayList;

import java.util.List;

import java.util.ListIterator;

public class ListIteratorDemo {

public static void main(String[] args) {

List list = new ArrayList<>();

list.add(“java”);

list.add(“python”);

list.add(“scala”);

//通过list集合的listIterator() 方法得到迭代器

/*ListIterator lit = list.listIterator();

while(lit.hasNext()) {

String s = lit.next();

System.out.println(s);

*//*java

python

scala*//*

}

System.out.println(“---------”);

//逆向遍历

*//*E previous0 返回列表中的上一个元素

boolean hasPrevious() 如果此列表迭代器在相反方向遍历列表时具有更多元索，则返回true*//*

while(lit.hasPrevious()) {

String s = lit.previous();

System.out.println(s);

*//*scala

python

java*//*

}*/

//获取列表迭代器

ListIterator lit = list.listIterator();

while(lit.hasNext()) {

String s = lit.next();

if(s.equals(“java”)) {

lit.add(“world”);

}

}

System.out.println(list); //[java, world, python, scala]

}

}

6.4 foreach（增强for循环）

增强for：简化数组和Collection集合的遍历

• 实现Iterable接口的类允许其对象成为增强型 for语句的目标

• 它是JDK5之后出现的，其内部原理是一个Iterator迭代器

• 格式

for(元素类型 变量名: 数组名或collection集合){

}

//范例

int[] arr = {1,2,3,4,5};

for(int i : arr) {

System.out.println(i);

}

• 范例：

package ceshi;

import java.util.ArrayList;

import java.util.List;

public class ForDemo {

public static void main(String[] args) {

//int类型数组

int[] arr = {1,2,3,4,5};

for(int i : arr) {

System.out.println(i);

/*

1

2

3

4

5*/

}

//String类型数组

String[] strArray = {“java”,“python”,“scala”};

for(String s : strArray) {

System.out.println(s);

/*java

python

scala*/

}

//集合

List list = new ArrayList<>();

list.add(“y1”);

list.add(“y2”);

list.add(“y3”);

for(String lt:list) {

System.out.println(lt);

/*y1

y2

y3*/

}

//判断：内部原理是一个Iterator迭代器

for(String s:list) {

if(s.equals(“y1”)) {

list.add(“y4”); //ConcurrentModificationException:并发修改异常

}

}

}

}

6.5 案例：List集合存储学生对象用三种方式遍历

• 测试类

package ceshi;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

public class ListDemo {

public static void main(String[] args) {

List list = new ArrayList<>();

Student s1 = new Student(“y1”,10);

Student s2 = new Student(“y2”,20);

Student s3 = new Student(“y3”,30);

list.add(s1);

list.add(s2);

list.add(s3);

//迭代器方式

Iterator it = list.iterator();

while(it.hasNext()) {

Student s = it.next();

System.out.println(s.getName()+“,”+s.getAge());

}

System.out.println(“----------”);

//for带索引方式

for(int i =0;i<list.size();i++) {

Student s = list.get(i);

System.out.println(s.getName()+“,”+s.getAge());

}

System.out.println(“----------”);

//增强for

for(Student s: list) {

System.out.println(s.getName()+“,”+s.getAge());

}

}

}

6.6 List集合子类特点

• ArrayList：底层数据结构数组实现，查询快，增删慢

• LinkedList：底层数据结构链表实现，查询慢，增删快

• 范例：分别用ArrayList和LinkedList存储字符串并遍历

package ceshi;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

public class ListDemo {

public static void main(String[] args) {

//1、创建ArrayList集合对象

ArrayList arraylist = new ArrayList<>();

arraylist.add(“java”);

arraylist.add(“python”);

arraylist.add(“scala”);

//增强for

for(String s: arraylist) {

System.out.println(s);

}

System.out.println(“-------”);

//普通for循环

for(int i=0;i< arraylist.size();i++) {

String s = arraylist.get(i);

System.out.println(s);

}

System.out.println(“-------”);

//迭代器的方式

Iterator it = arraylist.iterator();

while(it.hasNext()) {

String s = it.next();

System.out.println(s);

}

System.out.println(“-------”);

//2、创建LinkedList集合对象

LinkedList linkedList = new LinkedList<>();

linkedList.add(“a”);

linkedList.add(“b”);

linkedList.add(“c”);

//增强for

for(String s:linkedList) {

System.out.println(s);

}

System.out.println(“-------”);

//普通for

for(int i=0;i< linkedList.size();i++) {

String s = linkedList.get(i);

System.out.println(s);

}

System.out.println(“-------”);

//迭代器

Iterator it1 = linkedList.iterator();

while(it1.hasNext()) {

String s = it1.next();

System.out.println(s);

}

}

}

6.7 LinkedList集合特有方法

| 方法名 | 说明 |

| — | — |

| public void addFirst(E,e) | 在该列表开头插入指定的元素 |

| public void addLast(E,e) | 将指定的元索追加到此列表的末尾 |

| public E getFirst() | 返回此列表中的第一个元索 |

| public E getLast() | 返回此列表中的最后一个元素 |

| public E removeFirst | 从此列表中删除并返回第一个元素 |

| public E removeLast | 从此列表中删除并返回最后一个元素 |

package ceshi;

import java.util.LinkedList;

public class LinkedListDemo {

public static void main(String[] args) {

//创建集合对象

LinkedList linkedList = new LinkedList<>();

linkedList.add(“java”);

linkedList.add(“python”);

linkedList.add(“scala”);

System.out.println(linkedList); //[java, python, scala]

//1、public void addFirst(E,e) 在该列表开头插入指定的元素

linkedList.addFirst(“1”);

System.out.println(linkedList); //[1, java, python, scala]

//2、public void addLast(E,e) 将指定的元索追加到此列表的末尾

linkedList.addLast(“5”);

System.out.println(linkedList); //[1, java, python, scala, 5]

//3、public E getFirst() 返回此列表中的第一个元索

System.out.println(linkedList.getFirst()); //1

//4、public E getLast() 返回此列表中的最后一个元素

System.out.println(linkedList.getLast()); //5

//5、public E removeFirst 从此列表中删除并返回第一个元素

System.out.println(linkedList.removeFirst()); //1

System.out.println(linkedList);//[java, python, scala, 5]

//6、public E removeLast 从此列表中删除并返回最后一个元素

System.out.println(linkedList.removeLast()); //5

System.out.println(linkedList); //[java, python, scala]

}

}

7 Set集合

---

7.1 Set集合的概述和特点

• Set集合的特点

• 不包含重复元素的集合

• 没有带索引的方法，所以不能使用普通for循环

• Set集合是接口通过实现类实例化（多态的形式）

• HashSet：添加的元素是无序，不重复，无索引的

• LinkedHashSet: 添加的元素是有序，不重复，无索引的

• TreeSet: 不重复，无索引，按照大小默认升序排列

package ceshi;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Set;

public class SetDemo {

public static void main(String[] args) {

//创建Set集合对象

Set set = new HashSet<>();

//添加元素

set.add(“java”);

set.add(“python”);

set.add(“scala”);

//不包含重复元素

set.add(“java”);

//两种遍历方式

for(String s:set) {

System.out.println(s);

/*python

java

scala*/

}

System.out.println(“--------”);

Iterator it = set.iterator();

while(it.hasNext()) {

String s = it.next();

System.out.println(s);

/*python

java

scala*/

}

}

}

7.2 哈希值

• 哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

• Object类中有一个方法可以获取对象的哈希值

public int hashCode()：返回对象的哈希码值

• 对象的哈希值特点

• 同一个对象多次调用hashCode()方法返回的哈希值是相同的

• 默认情况下，不同对象的哈希值是不同的。而重写hashCode0方法，可以实现让不同对象的哈希值相同

package ceshi;

public class HashDemo {

public static void main(String[] args) {

//创建学生对象

Student s1 = new Student(“y1”,10);

//同一个对象多次调用hashCode()方法哈希值相同

System.out.println(s1.hashCode()); //460141958

System.out.println(s1.hashCode()); //460141958

System.out.println(“---------”);

//默认情况下，不同对象哈希值不同；重写hashCode()方法就可以使哈希值相同

Student s2 = new Student(“y2”,20);

System.out.println(s2.hashCode()); //1163157884

最后

看完美团、字节、腾讯这三家的面试问题，是不是感觉问的特别多，可能咱们又得开启面试造火箭、工作拧螺丝的模式去准备下一次的面试了。

开篇有提及我可是足足背下了1000道题目，多少还是有点用的呢，我看了下，上面这些问题大部分都能从我背的题里找到的，所以今天给大家分享一下互联网工程师必备的面试1000题。

注意不论是我说的互联网面试1000题，还是后面提及的算法与数据结构、设计模式以及更多的Java学习笔记等，皆可分享给各位朋友

互联网工程师必备的面试1000题

而且从上面三家来看，算法与数据结构是必备不可少的呀，因此我建议大家可以去刷刷这本左程云大佬著作的《程序员代码面试指南 IT名企算法与数据结构题目最优解》，里面近200道真实出现过的经典代码面试题。

-------");

//2、创建LinkedList集合对象

LinkedList linkedList = new LinkedList<>();

linkedList.add(“a”);

linkedList.add(“b”);

linkedList.add(“c”);

//增强for

for(String s:linkedList) {

System.out.println(s);

}

System.out.println(“-------”);

//普通for

for(int i=0;i< linkedList.size();i++) {

String s = linkedList.get(i);

System.out.println(s);

}

System.out.println(“-------”);

//迭代器

Iterator it1 = linkedList.iterator();

while(it1.hasNext()) {

String s = it1.next();

System.out.println(s);

}

}

}

6.7 LinkedList集合特有方法

| 方法名 | 说明 |

| — | — |

| public void addFirst(E,e) | 在该列表开头插入指定的元素 |

| public void addLast(E,e) | 将指定的元索追加到此列表的末尾 |

| public E getFirst() | 返回此列表中的第一个元索 |

| public E getLast() | 返回此列表中的最后一个元素 |

| public E removeFirst | 从此列表中删除并返回第一个元素 |

| public E removeLast | 从此列表中删除并返回最后一个元素 |

package ceshi;

import java.util.LinkedList;

public class LinkedListDemo {

public static void main(String[] args) {

//创建集合对象

LinkedList linkedList = new LinkedList<>();

linkedList.add(“java”);

linkedList.add(“python”);

linkedList.add(“scala”);

System.out.println(linkedList); //[java, python, scala]

//1、public void addFirst(E,e) 在该列表开头插入指定的元素

linkedList.addFirst(“1”);

System.out.println(linkedList); //[1, java, python, scala]

//2、public void addLast(E,e) 将指定的元索追加到此列表的末尾

linkedList.addLast(“5”);

System.out.println(linkedList); //[1, java, python, scala, 5]

//3、public E getFirst() 返回此列表中的第一个元索

System.out.println(linkedList.getFirst()); //1

//4、public E getLast() 返回此列表中的最后一个元素

System.out.println(linkedList.getLast()); //5

//5、public E removeFirst 从此列表中删除并返回第一个元素

System.out.println(linkedList.removeFirst()); //1

System.out.println(linkedList);//[java, python, scala, 5]

//6、public E removeLast 从此列表中删除并返回最后一个元素

System.out.println(linkedList.removeLast()); //5

System.out.println(linkedList); //[java, python, scala]

}

}

7 Set集合

---

7.1 Set集合的概述和特点

• Set集合的特点

• 不包含重复元素的集合

• 没有带索引的方法，所以不能使用普通for循环

• Set集合是接口通过实现类实例化（多态的形式）

• HashSet：添加的元素是无序，不重复，无索引的

• LinkedHashSet: 添加的元素是有序，不重复，无索引的

• TreeSet: 不重复，无索引，按照大小默认升序排列

package ceshi;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Set;

public class SetDemo {

public static void main(String[] args) {

//创建Set集合对象

Set set = new HashSet<>();

//添加元素

set.add(“java”);

set.add(“python”);

set.add(“scala”);

//不包含重复元素

set.add(“java”);

//两种遍历方式

for(String s:set) {

System.out.println(s);

/*python

java

scala*/

}

System.out.println(“--------”);

Iterator it = set.iterator();

while(it.hasNext()) {

String s = it.next();

System.out.println(s);

/*python

java

scala*/

}

}

}

7.2 哈希值

• 哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

• Object类中有一个方法可以获取对象的哈希值

public int hashCode()：返回对象的哈希码值

• 对象的哈希值特点

• 同一个对象多次调用hashCode()方法返回的哈希值是相同的

• 默认情况下，不同对象的哈希值是不同的。而重写hashCode0方法，可以实现让不同对象的哈希值相同

package ceshi;

public class HashDemo {

public static void main(String[] args) {

//创建学生对象

Student s1 = new Student(“y1”,10);

//同一个对象多次调用hashCode()方法哈希值相同

System.out.println(s1.hashCode()); //460141958

System.out.println(s1.hashCode()); //460141958

System.out.println(“---------”);

//默认情况下，不同对象哈希值不同；重写hashCode()方法就可以使哈希值相同

Student s2 = new Student(“y2”,20);

System.out.println(s2.hashCode()); //1163157884

最后

看完美团、字节、腾讯这三家的面试问题，是不是感觉问的特别多，可能咱们又得开启面试造火箭、工作拧螺丝的模式去准备下一次的面试了。

开篇有提及我可是足足背下了1000道题目，多少还是有点用的呢，我看了下，上面这些问题大部分都能从我背的题里找到的，所以今天给大家分享一下互联网工程师必备的面试1000题。

注意不论是我说的互联网面试1000题，还是后面提及的算法与数据结构、设计模式以及更多的Java学习笔记等，皆可分享给各位朋友

[外链图片转存中…(img-kMMCp63o-1714376412709)]

互联网工程师必备的面试1000题

而且从上面三家来看，算法与数据结构是必备不可少的呀，因此我建议大家可以去刷刷这本左程云大佬著作的《程序员代码面试指南 IT名企算法与数据结构题目最优解》，里面近200道真实出现过的经典代码面试题。

[外链图片转存中…(img-KrKdcWNo-1714376412709)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录