List1_Excise

1. List和Set集合的上层接口是( )
   A. java.util.Map B. java.util.Collection C. java.util.List D. java.util.Set

2. ArrayList类的底层数据结构是( A )
   A. 数组结构 B. 链表结构 C.哈希表结构 D.红黑树结构
   解析：A正确.B答案LinkedList是双向链表，每个元素都有一个前驱指针和后继指针，第一个元素的前驱指针指向最后一个元素，最后一个元素的后继指针指向第一个元素
   

3.LinkedList类的特点是( B )
A.查询快 B. 增删快 C.元素不重复 D. 元素自然排序

4.以下程序将ArrayList中的数据取出，转换后存入整形数组，程序最有可能报告何种异常。（ D）
public class Test1{
public static void main(String[] args){
List list = new ArrayList();
list.add(3.14);
list.add(4.13);
list.add(1.43);
int[] arr = new int[4];
for(int i = 0;i<list.size();i++){
arr[i]=(Integer)list.get(i);
}
}
}
A.ArrayIndexOutOfBoundsException
B.ArithmeticException
C.NullPointerException
D.ClassCastException//存的是引用类型
解析：D正确。list.get(i);获取到的元素类型是Object，需要先向下转型为double -然后才能进行基本类型的强转,转为int，我们说引用类型的强转需要遵循强转对象是通过向上造型来的
arr[i] = (int)(double)list.get(i);//double - Object -double基本类型才能强转int
5. 请看下列代码的输出结果是：（ D）。
public static void main(String[] args) {
List list = new ArrayList();
for (int i = 0; i < 10; i++) {
list.add(i);
}
List subList = list.subList(4, 9);
for (int i = 0; i < subList.size(); i++) {
subList.set(i, subList.get(i) * 10);
}
System.out.println(list);
}
A.[0, 1, 2, 3, 40, 50, 60, 70, 80, 90]
B.[0, 1, 2, 3, 4, 50, 60, 70, 80, 90]
C.[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
D.[0, 1, 2, 3, 40, 50, 60, 70, 80, 9]

6.阅读代码：
public class Cell implemens Comparable{
int row;
int col;
//getter()和setter()
//code here
}
//code here处，需要添加的代码段是（）。
A.public void compareTo(Cell o){
this.row - o.row;
}
B.public boolean compareTo(Cell o){
return this.row　＞　o.row;
}
C.public int compareTo(Cell o){
return this.row - o.row;
}
D.public int compareTo(Object o){
return this.row - o.row;
}

7.下列代码的运行结果是（A ）。
public class TestException {
static void fun() throws Exception {
try {
System.out.print("try1 ");
throw new Exception();
} catch (Exception e) {
System.out.print("exception1 ");
throw new Exception(e);
}
}
public static void main(String[] args){
try {
fun();
} catch (Exception e) {
System.out.print("exception2 ");
}
System.out.print("finish ");
}
}
A.try1 exception2 finish
B.try1 exception1 exception2
C.try1 exception1 exception2 finish
D.try1 exception1 finish

8.运行下面程序:
public class Test01{
public static void main(String[] args) {
try {
test();
System.out.println(“1…”);
} catch (ArithmeticException e) {
System.out.println(“2…”);
} catch (Exception e) {
System.out.println(“3…”);
} finally {
System.out.println(“end…”);
}
}
public static void test() {
String str = “cc”;
str.compareTo(“abc”);
}
}
输出的结果是：（A）。
A.1…
end…
B.2…
end…
C.2…
3…
end…
D.1…
2…
3…
end…

简答题：
1.怎么将集合转换为数组？怎么将数组转换为集合？
Collection提供了一个方法：toArray（），可以将当前集合转换为一个数组。
如果该数组可用（数组长度>=集合的size时），会将当前集合元素存入该数组后再将数组返回。
如果该数组不可用，会创建一个与参数组数同类型、并且长度与集合size一致的数组，再将元素存入并返回。
数组转换为集合
数组的工具类：Arrays提供了一个静态方法：asList(),
可以将一个数组转换为一个List集合。
2.什么是迭代器？如何使用？
Collection提供了一个方法：
Iterator iterator（）
该方法会返回一个用于遍历当前集合的迭代器实现类，使用它可以对集合进行遍历。
迭代器接口中规定了遍历集合元素所需要的相关方法，使用迭代器需要遵循的原则为：
问（hasNext()），取(next())，删(remove)，其中删除元素不是遍历过程中的必要操作。
注：不同的集合实现类都提供了一个用于遍历自身的迭代器实现类，
但我们不需要知道它们的名字，用多态的思想把它们看成Iterator进行操作即可。

3.什么是泛型？泛型的用处有哪些？
泛型是JDK5之后推出的新特性。
泛型也称为参数化类型，允许我们在使用一个类中通过其定义的泛型来指定其属性类型、方法的参数类型 或 返回值类型。泛型在集合中被广泛使用，用来指定集合中的数据类型。泛型的类型必须是引用类型，有泛型支持的类在使用时若不指定泛型的具体类型则默认为原型Object

4.迭代器、新循环、foreach在遍历集合时有何不同？

迭代器遍历集合首先要声明一个迭代器对象，通过集合调用iterator()方法将自身的迭代器给到声明的迭代器对象。通过该迭代器对象循环调用hasNext()方法判断迭代器中是否还有元素，如果有则调用next()取出集合元素。

新循环遍历集合不在使用下标，而是通过在for的小括号里定义元素类型 变量名：集合或数组，然后在大括号中输出，表面上看到是直接通过把集合元素依次给到变量输出，实际底层还是采用迭代器遍历
5.如何对List集合进行排序？
Collections.sort(List list);对集合自然排序，要求集合的元素所属类必须实现Comparable接口，重写compareTo()方法，用于定义该类元素之间的大小关系，java中很多常用的类都都实现了它，比如String，包装类。

• 2.使用Collections.sort()的重载的方法参数传入集合和比较器。，static void sort(List list, Comparator<? super T> c)比较器。Comparator是比较器接口，实现它需要重写方法：compare()方法，compare()定义两个要比较的元素的大小规则。通常我们直接以匿名内部类的形式创建，为集合的排序使用。该方法中的两个参数就是要比较的两个元素，方法返回值为比较大小的关系：
  • 当返回值>0,表示参数o1比o2大
  • 当返回值<0,表示参数o1比o2小
  • 当返回值=0，表示参数o1与o2相等
  • 即：从小到大为o1-o2,从大到小为o2-o1

编程题
第一大题：

1. 创建员工类Emp，类中的成员有：
   私有属性： String name， int age, String gender ，double salary
   无参构造方法，全参数构造方法
   每个属性的set和get方法
   重写toString方法，返回属性拼接成的字符串，格式为：“name=张三，age=22，gender=男,salary=5000.0”
   重写equals方法，要求若2个员工对象name相同，则对象equals比较的结果为true
   实现Comparable接口，定义Emp之间默认的排序规则为：按照年龄降序排列
2. 创建SortDemo类，在main方法中完成以下操作：
   要求用户从控制台输入若干员工信息，格式为：
   tom,22,男,5000.0;amy,33,女,5500;… 每个用户之间用;隔开，用户的属性之间用,隔开
   将每个员工信息解析出来并封装成Emp对象，并存入list集合
   使用增强for循环遍历集合，输出每个员工信息
   然后对集合中的员工按照年龄进行排序（降序），再次遍历集合，输出结果查看是否排序成功
3. 以上案例中，已知员工之间排序的默认规则是按照年龄排序，现在此基础上，要求对以上集合中的员工按照工资进行降序排列并遍历集合输出排序后的员工信息

package JAVA_API.num16_Collection.num16_2List.exter;
import java.util.Objects;
/**
 * 1. 创建员工类Emp，类中的成员有：
 * 	私有属性：  String  name，  int age, String gender ，double salary
 * 	无参构造方法，全参数构造方法
 * 	每个属性的set和get方法
 * 	重写toString方法，返回属性拼接成的字符串，格式为："name=张三，age=22，gender=男,salary=5000.0"
 * 	重写equals方法，要求若2个员工对象name相同，则对象equals比较的结果为true
 * 	实现Comparable接口，定义Emp之间默认的排序规则为：按照年龄降序排列
 * @author yyc
 * 2021/9/26 18:25
 */
public class Employee implements Comparable<Employee>{
    private String name;
    private int age;
    private String gender;
    private double salary;
    Employee(){}
    public Employee(String name, int age, String gender, double salary){
        setName(name);
        setAge(age);
        setGender(gender);
        setSalary(salary);
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
    public void setGender(String gender){
        this.gender = gender;
    }
    public String getGender(){
        return gender;
    }
    public void setSalary(double salary){
        this.salary = salary;
    }
    public double getSalary(){
        return salary;
    }

    //重写toString方法，返回属性拼接成的字符串，格式为："name=张三，age=22，gender=男,salary=5000.0"
    public String toString(){
        return "\""+ "name = " + name + ", age = " + age + ", gender = " + gender + ",salary = " + salary + "\"";
    }
    //重写equals方法，要求若2个员工对象name相同，则对象equals比较的结果为true
    public boolean equals(Object o){
        if (this == o){
            return true;
        }
        if (o == null || o.getClass() != getClass()){
            return false;
        }
        Employee employee = (Employee)o;
        return Objects.equals(name, employee.name);

    }

    //实现Comparable接口，定义Emp之间默认的排序规则为：按照年龄降序排列
    @Override
    public int compareTo(Employee o) {
        return o.age - age;
    }
}

package JAVA_API.num16_Collection.num16_2List.exter.Excise;

import JAVA_API.num16_Collection.num16_2List.exter.Employee;

import java.util.*;

/**
 * 2. 创建SortDemo类，在main方法中完成以下操作：
 *  要求用户从控制台输入若干员工信息，格式为：
 *  tom,22,男,5000.0;amy,33,女,5500;......   每个用户之间用;隔开，用户的属性之间用,隔开
 *  将每个员工信息解析出来并封装成Emp对象，并存入list集合
 *  使用增强for循环遍历集合，输出每个员工信息
 *  然后对集合中的员工按照年龄进行排序（降序），再次遍历集合，输出结果查看是否排序成功
 *  3. 以上案例中，已知员工之间排序的默认规则是按照年龄排序，现在此基础上，要求对以上集合中的员工按照工资进行降序排列并遍历集合输出排序后的员工信息
 *  *
 * @author yyc
 * 2021/9/27 10:31
 */
public class SortDemo {
    public static void main(String[] args) {
        System.out.println("请输入员工信息：格式为：(String,int,String,double),员工之间用分号隔开，属性用逗号隔开:");
        String str = new Scanner(System.in).nextLine();
        //1.按分号：拆分每个员工
        String[] emps = str.split(";");
        //2.创建集合，存储emp对象
        List<Employee> list = new ArrayList();
        //3.遍历所有员工
        for (int i = 0; i < emps.length ; i++){
            //4.按照逗号，拆分出员工的每个属性
            String[] info = emps[i].split(",");
            //5.封装成emp对象
            Employee e = new Employee(info[0],Integer.parseInt(info[1]),info[2],Double.parseDouble(info[3]));
            //6.存入list集合
            list.add(e);
        }
        System.out.println(list);

        //7.对以上集合中的员工按照工资进行降序排列并遍历集合输出排序后的员工信息
        Collections.sort(list, new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                /*Double s1 = o1.getSalary();
                Double s2 = o2.getSalary();
                //return s2 > s1 ? 1:-1;
                //return s2.compareTo(s1);或者直接调取Double的compareTo方法
                //Double底层重写的compareTo()实现了元素比较大小，调用的还是compare()方法
                 */
                return Double.compare(o2.getSalary(),o1.getSalary());
            }
        });
        //lambda表达式写法：
        //Collections.sort(list,(o1,o2) -> Double.compare(o2.getSalary(),o1.getSalary()));
        System.out.println(list);
    }
}

第二大题：

1. 创建一个List集合，并添加元素“ok.txt“，“hello.jpg”，“day01.rar”，“world.jpg”，“no.txt”，
   获取子集“hello.jpg”，“day01.rar”，“world.jpg“并输出子集
   再将子集中以“jpg”结尾的元素的后缀都替换成“png”;然后输出原集合查看内容

2.在一个List集合中生成20个随机整数(100以内)
然后按照从小到大的顺序排列，排好后再将第6个-第15个元素按照从大到小顺序排列，并最终输出集合

• 例如：1,2,3,4,5,15,14,13,12,11,10,9,8,7,6,16,17,18,19,20

/**
 * 1. 创建一个List<String>集合，并添加元素“ok.txt“，“hello.jpg”，“day01.rar”，“world.jpg”，"no.txt"，
 * 	获取子集“hello.jpg”，“day01.rar”，“world.jpg“并输出子集
 * 	再将子集中以“jpg”结尾的元素的后缀都替换成“png”;然后输出原集合查看内容
 *
 * 2.在一个List集合中生成20个随机整数(100以内)
 *  然后按照从小到大的顺序排列，排好后再将第6个-第15个元素按照从大到小顺序排列，并最终输出集合
 *  * 例如：1,2,3,4,5,15,14,13,12,11,10,9,8,7,6,16,17,18,19,20
 * @author yyc
 * 2021/9/26 23:55
 */
public class ListExcise {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("ok.txt");
        list.add("hello.jpg");
        list.add("day01.rar");
        list.add("world.jpg");
        list.add("no.txt");
        List<String> subList = list.subList(1,4);
        System.out.println(subList);
        //子集中以“jpg”结尾的元素的后缀都替换成“png”;
        for (int i = 0; i < subList.size(); i++){
            if (subList.get(i).endsWith("jpg")){
                subList.set(i, subList.get(i).replace("jpg","png"));
            }
        }
        System.out.println(subList);
        System.out.println(list);

        /*
        * 2.在一个List集合中生成20个随机整数(100以内)
         *  然后按照从小到大的顺序排列，排好后再将第6个-第15个元素按照从大到小顺序排列，并最终输出集合
         *  * 例如：1,2,3,4,5,15,14,13,12,11,10,9,8,7,6,16,17,18,19,20
        * */
        List<Integer> list1 = new ArrayList();
        Random random = new Random();
        for (int i = 0; i < 20; i++){
            int num = random.nextInt(100);
            list1.add(num);
        }
        System.out.println(list1);
        //按照从小到大的顺序排列，自然排序Comparable的compareTo()是自然排序;
        Collections.sort(list1);
        System.out.println(list1);
        List<Integer> subList1 = list1.subList(6,16);
        //排好后再将第6个-第15个元素按照从大到小顺序排列，
        System.out.println(subList1);
        Collections.sort(subList1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
               return o2-o1;
            }
        });
        System.out.println(subList1);
    }
}