JAVA基础

String、集合

目录

String、集合

一、String

1. String常见面试题：

2. String的常用方法：

3. StringBuilder：

4. StringBuilder的常用方法：

补充：

5. 正则表达式：

6.String支持与正则表达式相关的方法：

6.1matches()：使用给定的正则表达式(regex)验证当前字符串的格式是否符合要求，若符合则返回true，否 则返回false

6.2replaceAll()：将当前字符串中满足正则表达式(regex)的部分给替换为给定的字符串(s)

6.3split()：将当前字符串按照满足正则表达式(regex)的部分进行拆分，将拆分出的以String[]形式来返回

7.Object：对象/东西

7.1是所有类的鼻祖，所有类都直接或间接继承了Object，万物皆对象，为了多态

7.2调用Object类的equals()时默认比较的是还是==(即比较地址)，没有参考意义，所以常常重写equals() 来比较具体的属性值

二、集合

1. 什么是集合：

2. java集合框架中相关接口：

3. Collection常用方法：

4.集合的遍历：

5.增强型for循环：

6.泛型：

7.集合与数组的转换：

8. List接口：

9. List集合常见方法：

10.集合的排序

11.Set接口

---

一、String

1. String常见面试题：

public class StringDemo {
public static void main(String[] args) {
/*
常见面试题:
String s = new String("hello");
问: 如上语句创建了几个对象？
答: 2个
第一个:字面量"hello"
---java会创建一个String对象表示字面量"hello"，并将其存入常量池中
第二个:new String()
---new String()时会再创建一个字符串对象，并引用hello字符串的内容
*/
String s = new String("hello"); //创建了2个对象
String s1 = "hello"; //复用常量池中的字面量对象
System.out.println("s:"+s);
System.out.println("s1:"+s1);
System.out.println(s==s1); //false，==比较的是地址是否相同
//在实际应用中，String比较相等一般都是比较字符串内容是否相等
//因此我们需要使用equals()方法来比较两个字符串的内容是否相同
System.out.println(s.equals(s1)); //true，equals()比较的是内容是否相同
}
}

2. String的常用方法：

length() ：获取字符串的长度 ( 字符个数 )

String str = "我爱Java!";
int len = str.length(); //获取str的长度
System.out.println(len); //7

trim() ：去除当前字符串两边的空白字符

String str = " hello world ";
System.out.println(str); // hello world
str = str.trim(); //去除str两边的空白字符，并将去除之后的新的对象存储到str中
System.out.println(str); //hello world

toUpperCase()/toLowerCase() ：将当前字符串中的英文部分给转换为全大写 / 全小写

String str = "我爱Java!";
String upper = str.toUpperCase(); //将str中的英文部分转换为全大写，并存入upper中
System.out.println(upper); //我爱JAVA!
String lower = str.toLowerCase(); //将str中的英文部分转换为全小写，并存入lower中
System.out.println(lower); //我爱java!

startsWith()/endsWith() ：判断当前字符串是否是以给定的字符串开始的 / 结束的

String str = "thinking in java"; //java编程思想(经典书---工具书)
boolean starts = str.startsWith("think"); //判断str是否是以think开头的
System.out.println(starts); //true
boolean ends = str.endsWith(".png"); //判断str是否是以.png结尾的
System.out.println(ends); //false

charAt() ：返回当前字符串指定位置上的字符 ---- 根据位置找字符 \

// 111111----和下面的连成10/11/12/13/14/15
// 0123456789012345
String str = "thinking in java";
char c = str.charAt(9); //获取str中下标9所对应的字符
System.out.println(c); //i

indexOf()/lastIndexOf() ：检索给定字符串在当前字符串中第一次 / 最后一次出现的位置，根据字符串找位 置

// 111111
// 0123456789012345
String str = "thinking in java";
int index = str.indexOf("in"); //检索in在str中第1次出现的位置
System.out.println(index); //2
//从下标为3的位置开始找in第1次出现的位置
index = str.indexOf("in",3);
System.out.println(index); //5
index = str.indexOf("abc"); //若字符串在str中不存在，则返回-1
System.out.println(index); //-1
index = str.lastIndexOf("in"); //找in最后一次出现的位置
System.out.println(index); //9

substring() ：截取当前字符串中指定范围内的字符串 ( 含头不含尾 -- 包含 start ，但不包含 end)

// 1
// 01234567890
String str = "www.csdn.cn";
int start = str.indexOf(".")+1; //4，获取第1个点之后的下标
int end = str.lastIndexOf("."); //8，获取最后一个点的下标
String name = str.substring(start,end); //截取下标4到下标7之内的字符串
System.out.println(name); //tedu
name = str.substring(4); //从下标4一直到最后
System.out.println(name); //csdn.cn

静态方法valueOf()：将其它数据类型转换为String

int a = 123;
String s1 = String.valueOf(a); //将int型变量a转换为String类型并赋值给s1
System.out.println(s1); //123---字符串类型
double b = 123.456;
String s2 = String.valueOf(b); //将double型变量b转换为String类型并赋值给s2
System.out.println(s2); //123.456---字符串类型
String s3 = b+""; //任何类型与字符串相连，结果都变为字符串类型，效率低(一会儿讲)
System.out.println(s3); //123.456---字符串类型

3. StringBuilder：

由于 String 是不变对象，每次修改内容都会创建新的对象，因此 String 不适合频繁修改操作，为了解决这个

问题， java 提供了 StringBuilder 类。

StringBuilder 是专门用于修改字符串的一个类，内部维护一个可变的 char 数组，所做操作都是在这个数组

之上进行的，修改速度、性能优秀，并且提供了修改字符串的常见方式：增、删、改、插。

4. StringBuilder的常用方法：

append() ：增加内容 ------------------------ 增 delete() ：删除部分内容 -------------------- 删

replace() ：替换部分内容 ------------------- 改

insert() ：插入内容 ---------------------------- 插

String str = "好好学习Java";
//复制str的内容到builder中---------好好学习Java
StringBuilder builder = new StringBuilder(str);
//append():追加内容-----在末尾追加
builder.append("，为了找个好工作");
System.out.println(builder); //好好学习Java，为了找个好工作
//replace():替换部分内容(含头不含尾)
//将下标为9到15的内容替换为---就是为了改变世界
builder.replace(9,16,"就是为了改变世界");
System.out.println(builder); //好好学习Java，就是为了改变世界
//delete():删除部分内容(含头不含尾)
补充：
1. 数组是length属性，String字符串是length方法
2. 字符串内容若需要查看，那建议String-------------------------------实际应用中一般都是查看
字符串内容若需要频繁修改，那建议StringBuilder
3. StringBuilder和StringBuffer的区别：------现在先不用纠结，我先写着，学完线程之后才能理解
StringBuilder：非线程安全的，并发处理的，性能稍快---------一般都是用StringBuilder
StringBuffer：线程安全的，同步处理的，性能稍慢
4. getter/setter：
builder.delete(0,8); //删除下标为0到7的
System.out.println(builder); //，就是为了改变世界
//insert():插入内容
builder.insert(0,"活着"); //在下标为0的位置插入活着
System.out.println(builder); //活着，就是为了改变世界
/*
//StringBuilder的创建方式:
StringBuilder builder1 = new StringBuilder(); //空字符串
StringBuilder builder2 = new StringBuilder("abc"); //abc串
//基于String来创建StringBuilder
String str = "abc";
StringBuilder builder3 = new StringBuilder(str); //abc串
String str2 = builder3.toString(); //将builder3转换为String类型
*/

补充：

1. 数组是 length 属性， String 字符串是 length 方法

2. 字符串内容若需要查看，那建议 String------------------------------- 实际应用中一般都是查看

字符串内容若需要频繁修改，那建议 StringBuilder

3. StringBuilder 和 StringBuffer 的区别： ------ 现在先不用纠结，我先写着，学完线程之后才能理解

StringBuilder ：非线程安全的，并发处理的，性能稍快 --------- 一般都是用 StringBuilder

StringBuffer ：线程安全的，同步处理的，性能稍慢

4. getter/setter ：

public class Point {
/**
* 数据私有，设计getter/setter的原因:
* 1.很多框架都是基于getter/setter来配置获取数据的，可以理解为它是一种行为的标准
* 2.getter/setter时可以对数据进行控制，而public权限时无法对数据进行控制
*/
private int x;
private int y;
public int getX(){ //getter
return x;
}
public void setX(int x){ //setter
this.x = x;
}
public int getY(){
return y;
}
public void setY(int y){
this.y = y;
}
}
public class GetterSetterDemo {
public static void main(String[] args) {
Point p = new Point();
p.setX(100);
p.setY(200);
System.out.println(p.getX()+","+p.getY());
}
}

（其实有更便捷的方法使用注解，因为是讲基础就不在这说了留个悬念）

5. 正则表达式：

用于描述字符串的内容格式，使用它通常用于匹配一个字符串是否符合格式要求

正则表达式的语法： ------------------- 了解、不用纠结、不用深入研究

1.[]:表示一个字符,该字符可以是[]中指定的内容
例如:
[abc]:这个字符可以是a或b或c
[a-z]:表示任意一个小写字母
[a-zA-Z]:表示任意一个字母
[a-zA-Z0-9]:表示任意一个字母数字
[a-zA-Z0-9_]:表示任意一个数字字母下划线
[^abc]:该字符只要不是a或b或c
2.预定义字符:
.:表示任意一个字符,没有范围限制
\d:表示任意一个数字,等同于[0-9]
\w:表示任意一个单词字符,等同于[a-zA-Z0-9_]----单词字符指字母、数字和_
\s:表示任意一个空白字符
\D:不是数字
\W:不是单词字符
\S:不是空白字符
3.量词:
?:表示前面的内容出现0-1次
例如: [abc]? 可以匹配:a 或 b 或 c 或什么也不写
但是不能匹配：m或aaa
+:表示前面的内容最少出现1次
例如: [abc]+ 可以匹配:b或aaaaaaaaaa...或abcabcbabcbabcba....
但是不能匹配:什么都不写 或 abcfdfsbbaqbb34bbwer...
*:表示前面的内容出现任意次(0-多次)---匹配内容与+一致，只是可以一次都不写
例如: [abc]* 可以匹配:b或aaaaaaaaaa...或abcabcba....或什么都不写
但是不能匹配:abcfdfsbbaqbb34bbwer...
{n}:表示前面的内容出现n次
例如: [abc]{3} 可以匹配:aaa 或 bbb 或 aab 或abc 或bbc
但是不能匹配: aaaa 或 aad
{n,m}:表示前面的内容出现最少n次最多m次
例如: [abc]{3,5} 可以匹配:aaa 或 abcab 或者 abcc
但是不能匹配:aaaaaa 或 aabbd
{n,}:表示前面的内容出现n次以上(含n次)
例如: [abc]{3,} 可以匹配:aaa 或 aaaaa.... 或 abcbabbcbabcba....
但是不能匹配:aa 或 abbdaw...
4.()用于分组,是将小括号里面的内容看做是一个整体
例如: (abc){3} 表示abc整体出现3次. 可以匹配abcabcabc
但是不能匹配aaa 或abcabc
(abc|def){3}表示abc或def整体出现3次.
可以匹配: abcabcabc 或 defdefdef 或 abcdefabc
但是不能匹配abcdef 或abcdfbdef

6.String支持与正则表达式相关的方法：

6.1matches()：使用给定的正则表达式(regex)验证当前字符串的格式是否符合要求，若符合则返回true，否 则返回false

代码演示如下：

public class MatchesDemo {
public static void main(String[] args) {
/*
邮箱正则表达式:
[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\.[a-zA-Z]+)+
注意: \.中的这个\是正则表达式中的转义符
\\.中的第1个\，是在转义正则表达式中的\
*/
String email = "zhoutj@csdn.cn";
String regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";
//使用regex匹配email是否符合格式要求
boolean match = email.matches(regex);
if(match){
System.out.println("是正确的邮箱格式");
}else{
System.out.println("不是正确的邮箱格式");
}
}
}

6.2replaceAll()：将当前字符串中满足正则表达式(regex)的部分给替换为给定的字符串(s)

代码演示如下：

public class ReplaceAllDemo {
public static void main(String[] args) {
String line = "abc123def456ghi78";
line = line.replaceAll("[0-9]+","#NUMBER#");
System.out.println(line);
}
}

6.3split()：将当前字符串按照满足正则表达式(regex)的部分进行拆分，将拆分出的以String[]形式来返回

代码演示如下：

public class SplitDemo {
public static void main(String[] args) {
String line = "abc123def456ghi";
String[] data = line.split("[0-9]+"); //按数字拆分(数字就拆没了)
System.out.println(Arrays.toString(data)); //将data数组转换为字符串并输出
line = "123.456.78";
data = line.split("\\."); //按.拆(.就拆没了)
System.out.println(Arrays.toString(data));
//最开始就是可拆分项(.)，那么数组第1个元素为空字符串------------""
//如果连续两个(两个以上)可拆分项，那么中间也会拆出一个空字符串----""
//如果末尾连续多个可拆分项目，那么拆出的空字符串被忽略
line = ".123.456..78........";
data = line.split("\\."); //按.拆(.就拆没了)
System.out.println(Arrays.toString(data));
}
}

7.Object：对象/东西

7.1是所有类的鼻祖，所有类都直接或间接继承了Object，万物皆对象，为了多态

Object 中有两个经常被派生类重写的方法： toString() 和 equals()

调用 Object 类的 toString() 时默认返回：类的全称 @ 地址，没有参考意义，所以常常重写 toString() 来 返回具体属性的值。

注意： String 、 StringBuilder 等都重写了 toString() 来返回字符串内容了

public class ObjectDemo {
public static void main(String[] args) {
/*
输出引用变量时默认会调用Object类的toString()方法
该方法返回的字符串格式为: 类的全称@地址
但通常这个返回结果对我们的开发是没有意义的
我们真正想输出的应该是对象的属性值，我们认为Object类的toString()并不能满足需
求
因此常常需要重写toString()来返回具体的属性值
*/
Point p = new Point(100,200);
System.out.println(p); //输出引用类型变量时会默认调用Object类的toString()
System.out.println(p.toString());
}
}
package apiday02;
import java.util.Objects;
/**
* 点
*/
public class Point {
private int x;
private int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public String toString() {
return "Point{" +
"x=" + x +
", y=" + y +
'}';
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
}

7.2调用Object类的equals()时默认比较的是还是==(即比较地址)，没有参考意义，所以常常重写equals() 来比较具体的属性值

注意：

1. String 类已经重写 equals() 来比较字符串内容了，但 StringBuilder 并没有

2. 重写 equals() 的基本原则：

原则上要比较两个对象的属性值是否相同

两个对象必须是同一类型的，若类型不同则返回 false

public class ObjectDemo {
public static void main(String[] args) {
/*
调用Object类的equals()，内部还是在使用==比较地址，没有实际意义
若想比较对象的属性值是否相同，我们认为Object的equals()并不能满足需求
因此常常需要重写equals()
*/
/*
Point p1 = new Point(100,200);
Point p2 = new Point(100,200);
System.out.println(p1==p2); //false，==比较的是地址
//因为Point类重写了equals()方法，
//所以此处调用的是重写之后的equals()，比较的是属性的值是否相同
System.out.println(p1.equals(p2)); //true
*/
String s1 = new String("hello");
String s2 = new String("hello");
//String类重写了equals()来比较字符串内容是否相同
System.out.println(s1.equals(s2)); //true
StringBuilder builder1 = new StringBuilder("hello");
StringBuilder builder2 = new StringBuilder("hello");
//StringBuilder类没有重写equals()，因此调用的还是Object类的equals()，比较
的还是地址
System.out.println(builder1.equals(builder2)); //false
//s1与builder1的类型不同，所以equals()一定为false
System.out.println(s1.equals(builder1)); //false
}
}
package apiday02;
import java.util.Objects;
/**
* 点
*/
public class Point {
private int x;
private int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public String toString() {
return "Point{" +
"x=" + x +
", y=" + y +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Point point = (Point) o;
return x == point.x && y == point.y;
}
@Override
public int hashCode() {
return Objects.hash(x, y);
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
}

8.包装类：

java 定义了 8 个包装类，目的就是为了解决基本类型不能直接参与面向对象开发的问题，使用基本类型可以

通过包装类的形式存在。

包括： Integer 、 Character ， Byte ， Short ， Long ， Float ， Double ， Boolean ，其中 Character 和

Boolean 是直接继承自 Object 的，其余 6 个包装类继承自 java.lang.Number 类。

JDK1.5 推出了一个新的特性：自动拆装箱，当编译器编译时若发现是基本类型与包装类型之间的相互赋

值，将自动补齐代码来完成转换工作，这个过程称为自动拆装箱。

public class IntegerDemo {
public static void main(String[] args) {
//演示包装类的常用操作:
//1)可以通过包装类来获取基本类型的取值范围:
int max = Integer.MAX_VALUE; //获取int的最大值
int min = Integer.MIN_VALUE; //获取int的最小值
System.out.println("int的最大值为:"+max+"，最小值为:"+min);
long max1 = Long.MAX_VALUE; //获取long的最大值
long min1 = Long.MIN_VALUE; //获取long的最小值
System.out.println("long的最大值为:"+max1+"，最小值为:"+min1);
//2)包装类可以将字符串类型转换为对应的基本类型-------必须熟练掌握
String s1 = "38";
int age = Integer.parseInt(s1); //将字符串s1转换为int类型
System.out.println(age); //38---int类型
String s2 = "123.456";
double price = Double.parseDouble(s2); //将字符串s2转换为double类型
System.out.println(price); //123.456---double类型
/*
//触发自动装箱特性，会被编译为: Integer i = Integer.valueOf(5);
Integer i = 5; //基本类型到包装类型----装箱
//触发自动拆箱特性，会被编译为: int j = i.intValue();
int j = i; //包装类型到基本类型--------拆箱
*/
/*
Integer i1 = new Integer(5);
Integer i2 = new Integer(5);
System.out.println(i1==i2); //false，因为==比较的是地址
System.out.println(i1.equals(i2)); //true，Integer类中重写了equals()比较值
//Integer.valueOf()会复用-128到127范围内的数据---使用valueOf()更多一些
Integer i3 = Integer.valueOf(5);
Integer i4 = Integer.valueOf(5);
System.out.println(i3==i4); //true
System.out.println(i3.equals(i4)); //true，Integer类中重写了equals()比较值
*/
}
}

二、集合

1. 什么是集合：

集合与数组一样，可以保存一组元素，并且提供了操作数组元素的相关方法，使用更方便

2. java集合框架中相关接口：

java.util.Collection 接口：是所有集合的顶级接口，封装了所有集合所共有的东西，下面有多

种实现类，因此我们有更多的数据结构可以选择。

Collection 接口下面有两种常见的子接口：

java.util.List ：线性表，是可以重复集合，并且有序

java.util.Set ：不可重复集合，大部分实现类是无序的

集合只能存放引用类型元素，并且存放的是元素的引用

3. Collection常用方法：

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

循环体

} add() ：向集合中添加一个元素，成功添加则返回 true

size() ：返回当前集合的元素个数

isEmpty() ：判断当前集合是否为空集 . 当且仅当 size=0 时返回 true.

clear() ：清空集合

import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add("one"); //给集合添加元素
c.add("two");
c.add("three");
c.add("four");
c.add("five");
System.out.println(c); //Collection中重写了Object的toString()方法
int size = c.size(); //获取集合的元素个数
System.out.println("size:"+size); //5
boolean isEmpty = c.isEmpty(); //判断集合是否为空集(size为0表示为空
集)
System.out.println("是否为空集:"+isEmpty); //false
c.clear(); //清空集合
System.out.println("集合已清空");
System.out.println(c); //[]
System.out.println("size:"+c.size()); //0
System.out.println("是否为空集:"+c.isEmpty()); //true
}
}

contains() ：判断集合是否包含给定元素

remove() ：从集合中删除给定元素，成功删除返回 true.

import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add(new Point(1,2));
c.add(new Point(3,4));
c.add(new Point(5,6));
c.add(new Point(7,8));
c.add(new Point(9,0));
c.add(new Point(1,2));
/*
集合重写了Object的toString()方法，格式如下:
[元素1.toString(), 元素2.toString(), 元素3.toString(), ...]
*/
System.out.println(c);
Point p = new Point(1,2);
/*
boolean contains(Object o)
判断当前集合是否包含给定元素，判断依据是给定元素是否与集合元素存在equals比
较为true的情况
*/
boolean contains = c.contains(p);
System.out.println("是否包含:"+contains); //true
/*
boolean remove(Object o)
从集合中删除与给定元素equals比较为true的元素，若存在重复元素则只删除一次
*/
c.remove(p);
System.out.println(c);
}
}
package apiday03;
import java.util.Objects;
/**
* 点
*/
public class Point {
private int x;
private int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public String toString() {
return "(" + x + "," + y + ")";
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Point point = (Point) o;
return x == point.x && y == point.y;
}
@Override
public int hashCode() {
return Objects.hash(x, y);
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
}
package apiday03;
import java.util.ArrayList;
import java.util.Collection;
/**
* 集合是存放的是元素的引用
*/
public class CollectionDemo3 {
public static void main(String[] args) {
Collection c = new ArrayList();
Point p = new Point(1,2);
c.add(p); //将p添加到集合c中
System.out.println("p:"+p); //(1,2)
System.out.println("c:"+c); //[(1,2)]
p.setX(100);
System.out.println("p:"+p); //(100,2)
System.out.println("c:"+c); //[(100,2)]
}
}

addAll() ：将参数给定的集合中的所有元素添加到当前集合中，添加后当前集合发生改变则返

回 true

containsAll() ：判断当前集合中是否包含参数集合中的所有元素

retainAll() ：取交集

removeAll() ：删交集

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
/**
* 集合间操作的演示
*/
public class CollectionDemo2 {
public static void main(String[] args) {
Collection c1 = new ArrayList();
c1.add("java");
c1.add("c++");
c1.add(".net");
System.out.println("c1:"+c1); //[java, c++, .net]
Collection c2 = new ArrayList();
c2.add("android");
c2.add("ios");
c2.add("java");
System.out.println("c2:"+c2); //[android, ios, java]
/**
* boolean addAll(Collection c)
* 将参数给定的集合中的所有元素添加到当前集合中，添加后当前集合发生改变则返回
true
*/
c1.addAll(c2); //将c2添加到c1中
System.out.println("c1:"+c1); //[java, c++, .net, android, ios,
java]
System.out.println("c2:"+c2); //[android, ios, java]
Collection c3 = new ArrayList();
c3.add("c++");
c3.add("android");
c3.add("php");
System.out.println("c3:"+c3); //[c++, android, php]
/*
boolean containsAll(Collection c)
判断当前集合中是否包含参数集合中的所有元素
*/
boolean contains = c1.containsAll(c3); //判断c1中是否包含c3
System.out.println("包含所有:"+contains);
//取交集，c1中仅保留c1与c3的共有元素，c3不变
//c1.retainAll(c3);
//System.out.println("c1:"+c1); //[c++, android]
//System.out.println("c3:"+c3); //[c++, android, php]
//删交集，将c1中与c3的共有元素删除，c3不变
c1.removeAll(c3);
System.out.println("c1:"+c1); //[java, .net, ios, java]
System.out.println("c3:"+c3); //[c++, android, php]
}
}

4.集合的遍历：

Collection 接口提供了统一的遍历集合的方式：迭代器模式。通过 iterator() 方法可以获取一个

用于遍历当前集合元素的迭代器 (Iterator 接口 ) 。

java.util.Iterator 接口：定义了迭代器遍历集合的相关操作。不同的集合都实现了用于遍历自

身元素的迭代器实现类，我们无需记住它们的名字，从多态的角度把它们看成 Iterator 即可。

迭代器遍历遵循的步骤为：问、取、删，其中删除元素并不是必要操作

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("one");
c.add("#");
c.add("two");
c.add("#");
c.add("three");
c.add("#");
c.add("four");
c.add("#");
c.add("five");
System.out.println(c); //[one, #, two, #, three, #, four, #,
five]
/*
迭代器的常用方法:
1)boolean hasNext()-------问
询问集合是否还有"下一个"元素可供迭代
注意:迭代器默认开始位置是在集合第1个元素之前
无论调用多少次hasNext()方法，迭代器的位置都不会变
2)Object next()-----------取
迭代器向后移动一个位置来指向集合的下一个元素并将其获取
*/
Iterator it = c.iterator(); //获取集合c的迭代器
while(it.hasNext()){ //若有下一个元素
String str = (String)it.next(); //获取下一个元素
if("#".equals(str)){ //若str为#号
//c.remove(str); //迭代器遍历过程中不能通过集合方法增删元素，否
则会抛出异常
it.remove(); //删除next()方法所取的元素
}
System.out.println(str);
}
System.out.println(c);
}
}

5.增强型for循环：

JDK1.5 时推出了一个特性：增强型 for 循环，也称为新循环，让我们使用相同的语法遍历集合

和数组。

语法：

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

循环体

}

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* 增强型for循环:新循环
*/
public class NewForDemo {
public static void main(String[] args) {
String[] array = {"one","two","three","four","five"};
for(int i=0;i<array.length;i++){
System.out.println(array[i]);
}
//新循环遍历数组---会被编译器改回普通的for循环
for(String str : array){
System.out.println(str);
}
Collection c = new ArrayList();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
Iterator it = c.iterator();
while(it.hasNext()){
String str = (String)it.next();
System.out.println(str);
}
//新循环遍历集合---会被编译器改回迭代器遍历
for(Object obj : c){
String str = (String)obj;
System.out.println(str);
}
}
}

6.泛型：

JDK1.5 时推出了一个特性：泛型

泛型也称为参数化类型，允许我们在使用一个类时，传入某个类型来规定其内部的属性、方法

参数或返回值类型，使得我们使用的时候更加方便。

泛型在集合中被广泛使用，用来指定集合中元素的类型

若不指定泛型的具体类型，则默认为 Object ，获取泛型的值时，编译器会补充强转操

作。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* 泛型的演示
*/
public class GenericDemo {
public static void main(String[] args) {
Collection<String> c = new ArrayList<>();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
//c.add(123); //编译错误，参数类型违背了集合c所指定的泛型E的实际类型
String
//迭代器所指定的泛型应当与其遍历的集合的泛型一致
Iterator<String> it = c.iterator();
while(it.hasNext()){
String str = it.next(); //指定泛型后，获取元素无需再手动强转
System.out.println(str);
}
for(String str : c){
System.out.println(str);
}
}
}

7.集合与数组的转换：

        数组转换为List 集合

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 数组转换为集合:
* 数组的工具类java.util.Arrays提供了一个静态方法:asList()
* 该方法可以将一个数组转换为一个List集合
*/
public class ArrayToListDemo {
public static void main(String[] args) {
String[] array = {"one","two","three","four","five"};
System.out.println("array:"+ Arrays.toString(array));
//asList()方法会返回内部类ArrayList，该ArrayList内部直接引用给定数组
array
List<String> list = Arrays.asList(array);
System.out.println("list:"+list);
//对数组操作后，集合也会做相应的改变
array[1] = "six";
System.out.println("array:"+Arrays.toString(array));
System.out.println("list:"+list);
//对集合操作后，数组也会做相应的改变-----明天讲操作List集合
//添加元素/删除元素相当于要往数组中加元素/减元素，
//而数组是定长的，不会自动扩容/缩容的，因此会发生不支持操作的异常
//list.add("!!!!!"); //运行时发生不支持操作的异常
//如果我们需要增删元素，可另行创建一个集合同时包含list集合的元素即可
List<String> list2 = new ArrayList<>(list); //等同于先new再
addAll()
System.out.println("list2:"+list2);
list2.add("!!!!!");
System.out.println("list2:"+list2);
}
}

        集合转为数组

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
/**
* 集合转换为数组
* Collection提供了一个方法:toArray，可以将当前集合转换为一个数组
*/
public class CollectionToArrayDemo {
public static void main(String[] args) {
Collection<String> c = new ArrayList<>();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
System.out.println(c);
//若参数数组元素个数==集合元素个数，那就正常转换
//若参数数组元素个数>集合元素个数，则正常转换，同时末尾补默认值
//若参数数组元素个数<集合元素个数，则会按照集合大小给数组
String[] array = c.toArray(new String[0]);
System.out.println(Arrays.toString(array));
}
}

8. List接口：

继承自 Collection 接口， List 集合是可重复集合，并且有序，并且提供了一套可以通过下标操作元素的方法

常见的实现类：

java.util.ArrayList ：内部使用数组实现，查询性能更好 ( 直接下标查找 ) 、增删性能不太好

java.util.LinkedList ：内部使用链表实现，查询性能不太好，首尾增删元素性能更好

注意：在对集合操作的性能没有特别苛刻要求时，通过选择 ArrayList 。

9. List集合常见方法：

get() ：根据下标获取元素

set() ：将指定元素设置到指定位置 ，并返回被替换的元素 ( 用时接收 )

重载 add() ：将指定元素添加到指定位置，理解为插入操作

重载 remove() ：删除并返回指定位置元素

import java.util.*;
/**
* List集合:
* 1.List接口中提供了一套可以通过下标操作元素的方法
*/
public class ListDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("one");
list.add("two");
list.add("three");
list.add("four");
list.add("five");
System.out.println("list:"+list.toString());
/*
E get(int index):
获取指定下标所对应的元素
*/
String e = list.get(2);
System.out.println(e); //three
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
for(String s : list){
System.out.println(s);
}
Iterator<String> it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
System.out.println("----------------------------------");
/*
E set(int index, E e)
将给定元素设置到指定位置，返回被替换的元素
*/
String old = list.set(2,"six"); //将list中下标为2的元素设置为six
//list.set(2,"six"); //常规用法
System.out.println(list); //[one, two, six, four, five]
System.out.println(old);
/*
java.util.Collections为集合的工具类，包含了集合相关的静态方法
*/
Collections.reverse(list); //反转list集合元素(下标变化了)
System.out.println(list); //[five, four, six, two, one]
/*
* void add(int index, E e)
* 将给定元素e添加到index所指定的位置，相当于插入操作
*/
list.add(3,"three");
System.out.println(list); //[five, four, six, three, two, one]
/*
E remove(int index)
删除指定位置元素，并返回指定位置元素
*/
String o = list.remove(2);
//list.remove(2); //常规操作
System.out.println(list); //[five, four, three, two, one]
System.out.println(o); //six
}
}

subList() ：获取当前集合中指定范围内的子集 ( 含头不含尾 )

import java.util.ArrayList;
import java.util.List;
/**
* List提供了获取子集的操作:
* List subList(int start,int end): 含头不含尾
*/
public class ListDemo2 {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
for(int i=0;i<10;i++){
list.add(i*10); //自动装箱
}
System.out.println(list); //[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
//获取下标3到7的子集
List<Integer> subList = list.subList(3,8);
System.out.println(subList); //[30, 40, 50, 60, 70]
//将子集每个元素都扩大10倍
for(int i=0;i<subList.size();i++){
subList.set(i,subList.get(i)*10);
}
System.out.println(subList); //[300, 400, 500, 600, 700]
//注意:对子集的操作就是对原集合对应元素操作
System.out.println(list); //[0, 10, 20, 300, 400, 500, 600, 700, 80, 90]
list.remove(0);
System.out.println(list); //[10, 20, 300, 400, 500, 600, 700, 80, 90]
//原集合修改之后，子集将不能再进行操作了，操作则发生异常，但是可以重新获取子集
//System.out.println(subList); //发生不支持修改异常
}
}

10.集合的排序

                Collections是集合的工具类，里面定义了很多静态方法用于操作集合

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
/**
* 集合的排序
*/
public class SortListDemo {
public static void main(String[] args) {
Random rand = new Random();
List<Integer> list = new ArrayList<>();
for(int i=0;i<10;i++){
list.add(rand.nextInt(100));
}
System.out.println("list原始数据:"+list);
Collections.sort(list); //自然排序(从小到大)
System.out.println("list排序后数据:"+list);
Collections.reverse(list); //反转list集合(数据已经变化了)
System.out.println("list反转后:"+list);
}
}

Collections.sort(List list) 方法：可以对 list 集合进行自然排序 ( 从小到大 ) ， Collections.sort(List list) 方法要

求 List 集合中的元素必须是可比较的，若不可比较则直接发生编译错误，不允许排序。判定是否可比较的

标准为元素是否实现了 java.util.Comparable 接口。实际开发中，我们并不会让我们自己定义的类去实现

Comparable 接口的，因为这对我们的程序有侵入性。

侵入性：当我们调用某个 API 功能时，其要求我们为其修改其它额外的代码，这个现象叫做侵入性。侵入性

越强则越不利于程序的后期维护，应尽量避免。

重载的 Collections.sort(List list, Comparator c) 方法，可以通过 Comparator 来自定义规则

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* 字符串的排序
*/
public class SortListDemo2 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张三");
list.add("李四afsadsfsdaf");
list.add("王二麻子");
System.out.println("list原始数据:"+list);
//自定义排序规则:
Collections.sort(list, new Comparator<String>() {
/*
compare()方法用于定义o1和o2比较大小的规则，并用返回值表达大小关系
返回值实现的要求:-------不用纠结，去记下面的结论
1)如果返回值>0则表达的是o1>o2
2)如果返回值<0则表达的是o1<o2
3)如果返回值=0则表达的是o1=o2
结论:
1)前面的-后面的----------升序
2)后面的-前面的----------降序
*/
public int compare(String o1, String o2) {
return o1.length()-o2.length(); //升序
//return o2.length()-o1.length(); //降序
}
});
System.out.println("list排序后数据:"+list);
/*
List<String> list = new ArrayList<>();
list.add("jack");
list.add("rose");
list.add("tom");
list.add("black");
list.add("jerry");
list.add("Kabe");
System.out.println("list原始数据:"+list);
//对英文字符串排序时，会按首字母的ASCII码排序
//若首字母相同，则比较第2个字符的ASCII码，以此类推
Collections.sort(list);
System.out.println("list排序后数据:"+list);
*/
}
}
package ****;
import java.util.Objects;
/**
* 点
*/
public class Point{
private int x;
private int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
@Override
public String toString() {
return "(" + x + "," + y + ')';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Point point = (Point) o;
return x == point.x && y == point.y;
}
@Override
public int hashCode() {
return Objects.hash(x, y);
}
}
package ****;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
/**
* 排序自定义类型
*/
public class SortListDemo3 {
public static void main(String[] args) {
List<Point> list = new ArrayList<>();
list.add(new Point(5,8));
list.add(new Point(15,60));
list.add(new Point(56,50));
list.add(new Point(1,4));
list.add(new Point(9,6));
list.add(new Point(99,88));
System.out.println(list);
/*
Collections.sort(list, new Comparator<Point>() {
public int compare(Point o1, Point o2) {
int len1 = o1.getX()*o1.getX()+o1.getY()*o1.getY();
int len2 = o2.getX()*o2.getX()+o2.getY()*o2.getY();
return len1-len2; //升序
//return len2-len1; //降序
//return o1.getX()-o2.getX(); //按x坐标升序
//return o2.getY()-o1.getY(); //按y坐标降序
}
});
System.out.println(list);
*/
//jdk1.8，List集合自身提供了sort方法进行排序，sort方法依然需要传入比较器
list.sort(new Comparator<Point>() {
public int compare(Point o1, Point o2) {
int len1 = o1.getX()*o1.getX()+o1.getY()*o1.getY();
int len2 = o2.getX()*o2.getX()+o2.getY()*o2.getY();
return len1-len2; //升序
//return len2-len1; //降序
}
});
System.out.println(list);
}
}

11.Set接口

继承自 Collection 接口，元素是不可重复的，并且是无序的

常见的实现类：

HashSet 类：

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* Set集: 不可重复集合、并且无序
*/
public class SetDemo {
public static void main(String[] args) {
//小面试题: 如何去重?
List<String> list = new ArrayList<>();
list.add("one");
list.add("two");
list.add("three");
list.add("four");
list.add("five");
list.add("two");
System.out.println(list);
Set<String> set = new HashSet<>();
set.addAll(list);
System.out.println(set);
/*
Set<String> set = new HashSet<>();
set.add("one");
set.add("two");
set.add("three");
set.add("four");
set.add("five");
set.add("two");
set.add("five");
System.out.println(set);
*/
}
}

String\集合自我总结大概就以上内容，补充里是我对上述内容的补充，如果觉得有用请点个赞！