类型转换及各种方法！

基本数据类型转换
byte类型相加转换
byte a = 3;
byte b = 4;
byte c = (byte)(a + b);

int类型加double转换
Int a=3；
Double b=4；
Double= a+b；

String类型转换

String转int：
String str=”10”;
Integer.parseInt(str).var

String转Double：
String str=”10”;
Double.parseDouble(str).var

String转char：
String str=“是”;
Str.charAt(0).var
w.setSex(SC.nextLine().charAt(0));//键盘录入直接转char类型！
String money = SC.nextLine();
double b = Double.parseDouble(money);
w.setMoney(b); //键盘录入转double类型！

String转char[]数组：
String str=“1，2，3，4，5”;
str.toCharArray().var

String转Long：
String str=”20200000900000”;
Long.parseLong(str).var
Byte.parsebyte(str).var
Short.parseshort(str).var

Arrays类 数组的排序和遍历打印

int[] arr = {1,332,43,25,3324,34,335,4,45,2,43,52,54};
// 把数组转换成一个字符串打印
Arrays.toString(arr);
// 对数组进行升序排序
Arrays.sort(arr);

集合的迭代器遍历 for循环 增强for循环

ArrayListlist=new ArrayList<>();
List.add(40,50,70,90,100);

迭代器遍历：

Sting类型
ArrayList s1 = new ArrayList<>();
Iteratorit= s1.iterator();
while (it.hasNext()){
String s= it.next();
System.out.println(“s = “ + s);
}

Integer类型
Iterator iter = list.iterator();
while (iter.hasNext()){
Integer next = iter.next();
System.out.println(“next = “ + next);
}

for循环：
Integer []arr={40,50,70,90,100};
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}

增强for循环：
（int Integer自己定义一个变量 ：冒号后面写定义的数组或者集合名）
for (int a : arr) {
System.out.println(“a = “ + a);
}

HashSet集合遍历后直接会删除重复项

HashSeths=new HashSet<>();
hs.add(“刘备”);
hs.add(“关羽”);
hs.add(“张飞”);
hs.add(“刘备”);
System.out.println(hs.size());//自动删除重复值

正则表达式方法

BigInteger 的API 精准度低

BigInteger b1 = new BigInteger (“0.01”);
BigInteger b2 = new BigInteger (“0.09”);

1.b1.add(b2).var 加法！2.b1.subtract(b2).var 减法！
3.b1.multiply(b2).var 乘法！
4.b2.divide(b1).var 除法，除不尽取整数部分！**

ROUND_HALF_UP （四舍五入）
ROUND_FLOOR （去尾法）
ROUND_UP （进一法）

BigDecimal 的API 精准度更高

BigDecimal b1 = new BigDecimal(“0.01”);BigDecimal b2 = new BigDecimal(“0.09”);**

1.b1.add(b2).var 加法！2.b1.subtract(b2).var 减法！
3.b1.multiply(b2).var 乘法！
4.b2.divide(b1).var 除法，除不尽会报异常！
5.b1.divide( b2, 3, BigDecimal.ROUND_UP).var 避免除不尽的方式！
（被除对象，留几位数，四舍五入还是去尾或者进一法！）**

基本类型转字符串！

1. 直接在数值后面加一个空字符串！
String B=10+” “;
2. 通过String类静态方法valueOf( )!
int a=100;String.valueOf(a).var**

字符串常用方法 String类型常用方法！
字符串拼接 public String concat (String str)将当前字符串与参数字符串进行“拼接”返回一个新字符串。等效于加号拼接
字符串判断
public boolean contains (CharSequence s)判断参数字符串在当前字符串中是否存在(区分大小写)，存在返true。
public boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结尾(区分大小写)。
public boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始(区分大小写)
public int indexOf(String str) 返回指定子字符串第一次出现的字符串内的索引。如果不包含，则返回-1.
public int lastIndexOf(String str)返回指定子字符串最后一次出现的字符串中的索引。 如果不包含，则返回-1.
替换截取
public String replace(CharSequence target,CharSequence replacement) 将与字面目标序列匹配的字符串的每个子字符串替换为指定的文字替换序列。
public String substring(int beginIndex) 将当前字符串从beginIndex开始截取到末尾。
public String substring(int beginIndex, int endIndex)将当前字符串从beginIndex开始截取到endIndex - 1处。（包头，不包尾）
字符串转换
public char[] toCharArray() 将当前字符串转换为char[]数组。
public char charAt(int index) 将字符串中指定索引的字符获取
public String toLowerCase() 将当前字符串中的所有英文字符转换为小写，并返回一个转换后的新字符串，原字符串不变。
public String toUpperCase() 将当前字符串中的所有英文字符转换为大写，并返回一个转换后的新字符串，原字符串不变。
前后空格去除
public String trim() 去掉当前字符串的前后空格（空字符，制表符，换行符等），并返回一个新字符串，原字符串不变。
字符串的切割
public String[] split(String regex) 切割字符串——将字符串以regex作为分隔符进行切割。

String类型判断寻找方法使用！

String str = “I Love Java, I Love Heima”;//判断是否存在 “Java” 返回Boolean类型System.out.println(str.contains(“Java”));//true//判断是否以Heima字符串结尾 返回Boolean类型System.out.println(str.endsWith(“Heima”));//true//判断是否以Java开头 返回Boolean类型System.out.println(str.startsWith(“Java”));//false//判断 Java在字符串中的第一次出现位置System.out.println(str.indexOf(“Java”));//7//判断 itcast 所在的位置System.out.println(str.indexOf(“itcast”));//-1//最后一次出现的位置索引！System.out.println(str.lastIndexOf(“Love”));//15
———————————————————————————————————————————
String str = “I Love Java, I Love Heima”;
//1.将所有 Love 替换为 Like ,打印替换后的新字符串String replace = str.replace(“Love”, “Like”);//替换想换取的元素System.out.println(“replace = “ + replace);//I Like Java, I Like Heima//2.截取字符串 “I Love Heima”String sub1 = str.substring(13);//截取到末尾System.out.println(“sub1 = “ + sub1);//I Love Heima //3.截取字符串 “Java”String sub2 = str.substring(7, 11);//截取部分提供索引！System.out.println(“sub2 = “ + sub2);//Java
—————————————————————————————————————————————
String str = “I Love Java, I Love Heima”;//1 计算字符 a 出现的次数（要求使用toCharArray）char[] chars = str.toCharArray();int count = 0;for (int i = 0; i < chars.length; i++) { if (chars[i]==’a’) { count++;}}System.out.println(“count = “ + count);//3
**//2 计算字符 a 出现的次数（要求使用charAt）count = 0;for (int i = 0; i < str.length(); i++) { if (str.charAt(i)==’a’) { count++; }}System.out.println(“count = “ + count);//3
String str1 = “ A B C “; String str2 = str1.trim();//去除前后空格
String str1 = “abc,123,def”;String[] arr1 = str1.split(“,”);//按照逗号切割System.out.println(Arrays.toString(arr1));
结果： [abc, 123, def]
. + ? 一些正则表达式的特殊字符作为切割字符串，需要将这些字符进行转义，在前面加上\**

时间API使用
Date date=new Date(); SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);String strDate = sdf.format(date); //strDate为yyyy-MM-dd HH:mm:ss格式的正时间。

//当前时间LocalDateTime now = LocalDateTime.now();System.out.println(“now = “ + now);//指定时间LocalDateTime ldt = LocalDateTime.of(2021,12,2,17,17,17);System.out.println(“ldt = “ + ldt);**

LocalDateTime获取功能
public int getYear() 获取年 public int getMonthValue() 获取月份（1-12） public int getDayOfMonth() 获取月份中的第几天（1-31） public int getDayOfYear() 获取一年中的第几天（1-366） public DayOfWeek getDayOfWeek() 获取星期 public int getHour() 获取小时 public int getMinute() 获取分钟 /public class LocalDateTimeDemo2 { public static void main(String[] args) { LocalDateTime now = LocalDateTime.now(); //年，月，日
int year = now.getYear(); int monthValue = now.getMonthValue(); int dayOfMonth = now.getDayOfMonth(); System.out.println(year+”-“+monthValue+”-“+dayOfMonth); //时，分，秒 int hour = now.getHour(); int minute = now.getMinute(); int second = now.getSecond(); System.out.println(hour+”:”+minute+”:”+second);** //星期 DayOfWeek dayOfWeek = now.getDayOfWeek(); System.out.println(“dayOfWeek = “ + dayOfWeek);//THURSDAY 星期四 int value = dayOfWeek.getValue(); System.out.println(“week = “ + value);//4** }
时间的增加或减少 public LocalDateTime plusYears (long years) 添加或者减去年 public LocalDateTime plusMonths(long months) 添加或者减去月 public LocalDateTime plusDays(long days) 添加或者减去日 public LocalDateTime plusHours(long hours) 添加或者减去时 public LocalDateTime plusMinutes(long minutes) 添加或者减去分 public LocalDateTime plusSeconds(long seconds) 添加或者减去秒 public LocalDateTime plusWeeks(long weeks) 添加或者减去周** 时间的修改 public LocalDateTime withYear(int year) 直接修改年 public LocalDateTime withMonth(int month) 直接修改月 public LocalDateTime withDayOfMonth(int dayofmonth) 直接修改日期(一个月中的第几天) public LocalDateTime withDayOfYear(int dayOfYear) 直接修改日期(一年中的第几天) public LocalDateTime withHour(int hour) 直接修改小时 public LocalDateTime withMinute(int minute) 直接修改分钟 public LocalDateTime withSecond(int second) 直接修改秒 /public class LocalDateTimeDemo3 { public static void main(String[] args) { LocalDateTime now = LocalDateTime.now();
加或者减 年月日时分秒周！ LocalDateTime localDateTime = now.plusYears(100);//正数加上，负数减去 System.out.println(“localDateTime = “ + localDateTime);//2122-03-05T22:16:44.676487 直接修改 年月日时分秒！ LocalDateTime localDateTime1 = now.withYear(1998);//直接修改 System.out.println(“localDateTime1 = “ + localDateTime1);1998-03-05T22:16:44.676487 }}**

ArrayList集合常用方法
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() 返回集合中的元素的个数

ArrayListlist=new ArrayList<>();list.add(“唐僧”);list.add(“八戒”);list.add(“悟空”);list.add(“沙僧”);list.add(“白龙马”);System.out.println(“list = “ + list);//list = [唐僧, 八戒, 悟空, 沙僧, 白龙马]int size = list.size(); //返回集合中的元素的个数System.out.println(“size = “ + size); //5
String s = list.get(2) // 返回指定索引处的元素
System.out.println(“s = “ + s); //悟空
String S= list.set(2, “美猴王”);//修改指定索引处的元素,前面写索引后面写新元素System.out.println(list); //[唐僧, 八戒, 美猴王, 沙僧, 白龙马]boolean S1 = list.remove(“沙僧”);//删除指定元素 但是不准确会删除所有元素System.out.println(list);//[唐僧, 美猴王, 悟空, 沙僧, 白龙马]
Collections.addAll(list, 唐僧, 八戒, 美猴王, 沙僧, 白龙马);//此方法可直接添加所有数据！**

String类型删除使用forr自减遍历
注意：如果是自增遍历可能会导致删除不干净，而使用自减遍历可以避免这种弊端！
for (int i = list.size() - 1; i >= 0; i—) { //对集合进行遍历！ String s1= list.get(i); //将遍历的值临时赋给s1 if(s1.equals(“白龙马”)){ //使用equlas进行比较，并删除！ list.remove(“白龙马”); }

注意：如果数据是Integer 删除remove（）括号是默认是位置索引。
如果想让直接删除元素直接定义一个同类型的变量，放在remove（）括号中！
ArrayListlist=new ArrayList<>();list.add(1);list.add(2);list.add(3);list.add(4);list.remove(3); //默认为元素索引位置 而不是元素值！System.out.println(“list = “ + list); //list = [1, 2, 3]
删除Integer中的所指定元素！
Integer e=3; //比如：定义变量赋值3list.remove(e); //remove（）写变量，那么直接就会集合中的元素。System.out.println(list); //[1, 2]

集合字符串的遍历

所有引用数据类型在集合中都可使用fori，forr进行遍历！

数组名.fori 自增遍历！

for (int i = 0; i <list.size() ; i++) { String s = list.get(i); System.out.println(“s = “ + s);
// s = 唐僧 s = 沙僧 s = 八戒 s = 悟空 s = 沙僧 s = 白龙马
**}
数组名.forr 自减遍历！
**for (int i = list.size() - 1; i >= 0; i—) { String s = list.get(i); System.out.println(“s = “ + s);
}
// s = 白龙马 s = 沙僧 s = 悟空 s = 八戒 s = 沙僧 s = 唐僧

使用for循环对学生对象进行遍历输出！

ArrayListstudents=new ArrayList<>(); students.add(new Student(“李四”,20,”男”)); students.add(new Student(“王二”,20,”女”)); for (int i = 0; i < students.size(); i++) { Student S1=students.get(i); System.out.println(S1.getName()+”,”+S1.getAge()+”,”+S1.getSex()); // 李四,20,男 王二,20,女 }**

Collection-常用方法
（科莱科森）
Collecton是集合的顶层根接口，下面有俩个子类 一个List一个Set。

public boolean add(E e)： 把给定的对象添加到当前集合中 。public void clear() :清空集合中所有的元素。public boolean remove(E e): 把给定的对象在当前集合中删除。public boolean contains(Object obj): 判断当前集合中是否包含给定的对象。public boolean isEmpty(): 判断当前集合是否为空。public int size(): 返回集合中元素的个数。public Object[] toArray(): 把集合中的元素，存储到数组中

示例：
< >中必须放置的是引用数据类型！
也可以使用List这个父类型：Listlist=new ArrayList<>();
实例化集合：父类型变量collection实现子类型ArrayList对象！
Collection collection = new ArrayList<>();collection.add(“詹姆斯”);collection.add(“麦迪”);collection.add(“科比”);collection.add(“奥尼尔”);System.out.println(“collection = “ + collection); //直接打印集合
// collection = [詹姆斯, 麦迪, 科比, 奥尼尔]collection.remove(“科比”); //删除集合中的某个元素System.out.println(“collection = “ + collection);//collection = [詹姆斯, 麦迪, 奥尼尔]Object[] objects = collection.toArray();//将集合转为数组类型！for (Object obj : objects) { System.out.println(“obj = “ + obj);// obj =詹姆斯 ,obj = 麦迪 ,obj = 奥尼尔}collection.clear(); //删除集合中所有元素！System.out.println(“collection = “ + collection);//collection = [ ]**

Itearator 迭代器
（依体而瑞特二）
注意：1.迭代器只能使用一次 ，迭代动作已经结束，不能继续next获取元素。
2.迭代器使用过程中不可以用集合对象直接增删元素，删除用迭代器的方法。

通用定义格式：
Iterator iter = 集合对象.iterator();while(iter.hasNext()){ //有元素 元素 = iter.next(); //操作元素}
实例：
Collectioncollection=new ArrayList<>(); collection.add(“詹姆斯”); collection.add(“麦迪”); collection.add(“科比”); collection.add(“奥尼尔”);
//变量名.迭代器名称.var //collection.iterator().var Iterator iter = collection.iterator();//变量名.iterator.var while (iter.hasNext()){ // 迭代器定义的变量名.hasNext（） String next = iter.next(); // 迭代器变量名.next().var System.out.println(“next = “ + next);
if(“科比”.equals(next)){ //迭代器while循环中删除元素！ iterator.remove(); }
}
System.out.println(“collection = “ + collection);
collection = [詹姆斯, 麦迪 , 奥尼尔]//删除元素后结果！
}
}
增强for循环
增强for循环底层还是通过迭代器实现的！
快捷键：集合名/数组名.for
Collectioncollection=new ArrayList<>();collection.add(“奔驰”);collection.add(“宝马”);collection.add(“奥迪”);collection.add(“保时捷”);for(String S:collection){ //（变量类型 变量名 ：集合名/数组名） String s = S; System.out.println(“s = “ + s);}

List集合的常用方法！
常用子类：1. ArrayList集合：底层就是数组（查询快，增删慢，并且有索引！）
2. Vector集合：底层结构也是数组（线程安全，同步安全的，低效率，用的少！）
3. LinkedList集合：底层结构是双向链表（可以双向查询，效率比单向链表高）

List继承了Collection中所有方法，元素具备索引特性，因此新增了一些含有索引的特有方法，如下：
- public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
- public E get(int index):返回集合中指定位置的元素。
- public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
- public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
实例：
Listlist=new ArrayList<>(); list.add(“貔貅”); list.add(“囚牛”); list.add(“狻猊”); list.add(“赑屃”); list.add(“麒麟”); list.add(“青龙”); System.out.println(“list = “ + list); // list = [貔貅, 囚牛, 狻猊, 赑屃, 麒麟, 青龙] list.add(1,”爱财”); //（索引，“元素”）添加元素到指定索引位置！ System.out.println(“list = “ + list); //list = [貔貅, 爱财, 囚牛, 狻猊, 赑屃, 麒麟, 青龙] list.remove(5); //（索引）删除指定索引元素 System.out.println(“list = “ + list); //list = [貔貅, 爱财, 囚牛, 狻猊, 赑屃, 青龙] list.set(2,”狻猊换朱雀”); //(索引，“替换的新元素”)替换索引位置的元素！ System.out.println(“list = “ + list); //list = [貔貅, 爱财, 狻猊换朱雀, 狻猊, 赑屃, 青龙]
LinkedList集合
(林克音德利斯特)
内部构造：[^][数据][后一个地址] === [前一个地址][数据][后一个地址]···**

LinkedList特有方法: 只可以在定义LinkedList集合时才可使用！
public void addFirst(E e):将指定元素插入此列表的开头。public void addLast(E e):将指定元素添加到此列表的结尾。public E getFirst():返回此列表的第一个元素。public E getLast():返回此列表的最后一个元素。public E removeFirst():移除并返回此列表的第一个元素。public E removeLast():移除并返回此列表的最后一个元素。**

实例：
LinkedList list = new LinkedList<>();//注意集合必须是LinkedList！list.addFirst(“A”);list.addFirst(“B”);list.addFirst(“C”);list.addFirst(“D”);list.addFirst(“E”); //因为使用addFirst添加数据，最后添加的会在输出的最前面（弹夹效应）System.out.println(“list = “ + list); //list = [E, D, C, B, A]String s = list.removeFirst(); //删除列表中的第一个元素，此时最后一个进去的成为了第一个！System.out.println(“list = “ + list);//list = [D, C, B, A]list.addFirst(“输出页面第一个”);// 再添加数据 虽然是最后添加的 但是输出是第一个！System.out.println(“list = “ + list);//list = [输出页面第一个, D, C, B, A]LinkedList也用于List中的方法，比如add添加数据等等。LinkedList list1 = new LinkedList<>();list1.add(“A”);list1.add(“B”);list1.add(“C”); //此时输出为A,B,C是因为add执行输出是队列效应先赋值的先打印System.out.println(“list1 = “ + list1);//list1 = [A, B, C]

Set集合 全部都没有索引
Set集合也是Collection集合的子类型，没有特有方法，Set的定义要求比Collection更严谨

HashSet集合
HashSet：底层结构哈希表结构。
具有特点 : 去重，无索引，无序特点。
哈希表结构的集合，操作效率会非常高。
学生类：如果写了equlas（）and hashCode（）方法，对象中输出时也会自动去重！
示例：
HashSet set = new HashSet<>();set.add(10);set.add(10);set.add(30);set.add(40);set.add(10);set.add(50); //保证元素唯一，不会有重复的出现！ System.out.println(“set = “ + set); //输出结构是无序的！set = [50, 40, 10, 30]但其内部有排序**

HashSetset=new HashSet<>();
set.add(“唐山”);set.add(“石家庄”);set.add(“唐山”);set.add(“石家庄”);set.add(“北京”);System.out.println(“set = “ + set); //字符串类型也是一样的！set = [唐山, 石家庄, 北京]
Iterator iterator = set.iterator(); // 变量名.迭代器名（iterator）.var while (iterator.hasNext()){ String next = iterator.next(); //HashSet集合 String类型 Iterator方法也可以使用！ System.out.println(“next = “ + next);// next = 唐山，next = 石家庄， next = 北京}**

LinkedHashSet集合
LinkedHashSet底层结构：链表加哈希表结构
有去重效果，有序但不是排序，这里的有序指你所存进来的顺序是什么样就是什么样！
示例：
LinkedHashSet list=new LinkedHashSet<>();list.add(20);list.add(10);list.add(30);list.add(10);//逐级添加并删除重复值，到这里会匹配前面的元素，有10就不会添加这个10进去！System.out.println(“list = “ + list); //输出结果：list = [20, 10, 30]**

数组随机赋值并排序！
**public class Demo03 { public static void main(String[] args) { Random sc = new Random(); int[] arr = new int[100]; //定义个数100的动态数值！ for (int i = 0; i < arr.length; i++) { arr[i] = sc.nextInt(100) + 1; System.out.print(arr[i] + “ “); //利用for循环给数组中的元素赋值！ } for (int i = 0; i < arr.length; i++) { //冒泡排序 for (int j = 0; j < arr.length - 1 - i; j++) { if (arr[j] > arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } System.out.println(); System.out.print(Arrays.toString(arr)); }} Collection接口及子类分析图

Collections.sort(List, new Comparator() { @Override public int compare(Integer o1, Integer o2) { return o2-o1; }}); Lambda表达式： Collectione.sort(list,(o1,o2)->o2-o1)}: ↑ //Collections.sort实现降序

Collection示例
public class CollectionReview {
public static void main(String[] args) {
test1();

}

private static void test1() {
// Collection为接口，使用多态进行创建
Collection collection = new Vector<>();
collection.add(“gogogo”);
collection.add(“pap”);
collection.add(“niko”);
collection.add(“kitty”);

Collection coll = new ArrayList<>();
coll.add(“niko”);
coll.add(“kitty”);
coll.add(“pecuyu”);

// collection.clear(); // 清空集合
//System.out.println(collection.isEmpty()); // 集合是否为空

// int size = collection.size(); // 获取集合大小
// System.out.println(size);

// boolean contains = collection.contains(“niko”); // 是否包含另一个元素
// System.out.println(contains);
//boolean containsAll = collection.containsAll(coll); //是否完全包含另一个集合
//System.out.println(containsAll);

// collection.remove(“kitty”); // 删除第一个匹配项，删除了匹配项则返回true
// boolean removeAll = collection.removeAll(coll); // 删除与指定集合有交集的部分，原集合有改变就返回true
// System.out.println(removeAll);

//boolean retainAll = collection.retainAll(coll);// 保留与指定集合有交集的部分，原集合有改变就返回true
//System.out.println(retainAll);

ArrayList使用示例

// iterator 迭代器， 方式1

Iterator iterator = collection.iterator();
while(iterator.hasNext()){
System.out.print(iterator.next()+” “);
}
System.out.println(“\n”+”—————————-“);

// 方式2 ，for循环完iterator1就会被销毁，节约内存提高效率
for (Iterator iterator1 = collection.iterator(); iterator1.hasNext(); ) {
System.out.print(iterator1.next()+” “);

}
System.out.println(“\n”+”—————————-“);

Object[] array = collection.toArray(); // 转化为object数组
for (Object string : array) {
System.out.print(string+” “);
}
System.out.println(“\n”+”—————————-“);
String[] arr=new String[collection.size()];
String[] array2 = collection.toArray(arr); // 指定要转化的数组类型
for (String string : array2) {
System.out.print(string+” “);
}
}
public class ArrayListReview {
public static void main(String[] args) {
ArrayList infosList=new ArrayList<>();
infosList.add(new Info(0, “aaa”));
infosList.add(new Info(1, “bbb”));
infosList.add(new Info(2, “ccc”));
infosList.add(new Info(3, “ddd”));
infosList.add(1, new Info(4, “eee”)); // 按索引插入到指定位置
// foreach遍历输出
for (Info info : infosList) {
System.out.println(info);
}
System.out.println(“————————————“);
// 截取字串
List subList = infosList.subList(1, 3);
subList.add(new Info(30, “fly”));
printList(subList);
ArrayList newInfosList=new ArrayList<>();
newInfosList.add(new Info(11, “qqq”));
newInfosList.add(new Info(12, “www”));
ArrayList ss=new ArrayList<>();
// infosList.addAll(newInfosList); // 添加一个指定集合到原集合最后，注意两个集合的泛型参数一致
infosList.addAll(2,newInfosList); // 将指定集合插入到指定位置
//printList(infosList);
Info info = infosList.get(2); // 取出指定位置的元素
System.out.println(info);
infosList.set(0, new Info(10, “rrr”)); // 替换指定索引位置的元素
//printList(infosList);
int index = infosList.indexOf(info); //根据元素获取元素第一次出现的索引，不存在则返回-1
int lastIndex = infosList.lastIndexOf(info); // 取出元素的最后一个匹配项的索引
int indexOf = infosList.indexOf(new Info(4,”eee”)); // 重写了Info类的hashCode与equals方法，用于判断两个对象是否相同
System.out.println(“index=”+indexOf);
//printList(infosList);
// 通过反射拿到的removeRange方法
removeRange(infosList, 1, 3);
//printList(infosList);
// listIterator从前往后迭代
ListIterator listIterator = infosList.listIterator();
while(listIterator.hasNext()){
// 最后抛出错误，java.util.NoSuchElementException，不要每次取都掉用next方法，它每调用一次，迭代器指针向前移动一位
// System.out.println(“id=”+listIterator.next().getId()
// +”adress=”+listIterator.next().getAdress());
Info next = listIterator.next(); // 正确做法，调用一次要取出元素，然后操作属性
System.out.println(“id=”+next.getId()+” adress=”+next.getAdress());
}
// 往前迭代，必须在往后迭代之后用
while(listIterator.hasPrevious()){ // 当有上一个元素时
Info previous = listIterator.previous(); // 获取上一个元素
System.out.println(“id=”+previous.getId()+” adresss=”+previous.getAdress());
}
// 通过数组来转化成一个List，虽然可以把数组转成集合，但是集合的长度不能改变。
String[] a=new String[]{“hello”,”world”,”just”,”do”,”it”};
List asList = Arrays.asList(a);
//asList.add(“gogogo”); //不可修改asList，会抛出UnsupportedOperationException
// 泛型使用
// ArrayList