第四周 Day6

最新推荐文章于 2024-09-14 11:42:20 发布

Reacher1111

最新推荐文章于 2024-09-14 11:42:20 发布

阅读量176

点赞数

文章标签： linq microsoft c#

本文链接：https://blog.csdn.net/Reacher1111/article/details/122529158

版权

1.List集合的专有遍历

1.Collection的Iterator迭代器
2.传统方式Object[] toArray()
3.get(int index)+size()相结合
4.列表迭代器:ListIterator<E> listIterator()

列表迭代器:ListIterator<E> listIterator():

        正向遍历:
                   boolean hasNext():判断是有更多下一个元素可以迭代(遍历)
                   E next()获取下一个可以遍历元素
    
        反向遍历
 
                   boolean hasPrevious():判断是否有更多的上一个元素可以迭代(遍历)
                   E previous():获取上一个上一个可以遍历的元素

public class List1 {
    public static void main(String[] args) {
        //List集合储存String类型
        List<String> list = new ArrayList<>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("javaEE");

        //使用list集合的专有遍历方式列表迭起器
        //正向遍历
        ListIterator<String> ls = list.listIterator();
        while (ls.hasNext()){
            String s = ls.next();
            System.out.println(s);
        }
        System.out.println("------------------------------");
        //  boolean hasPrevious():判断是否有更多的上一个元素可以迭代(遍历)
        //  E previous():获取上一个上一个可以遍历的元素
        //反向遍历--->不能单独用,必须先有正向遍历
        while (ls.hasPrevious()){
            String s = ls.previous();
            System.out.println(s);
        }
    }
}

2.ConcurrentModificationException异常

public class List2{
    public static void main(String[] args){
        List<String> list = new ArrayList<>() ;
        
        list.add("hello") ;
        list.add("world") ;
        list.add("java") ;
       Iterator<String> it = list.iterator();
        while (ls.hasNext()){
            if("world"equals(s)){
               list.add("javaee") ;
            }             
        }
           System.out.println(list);//出现:ConcurrentModificationException异常
    }
}

如上代码所示:
    出现了一个问题"ConcurrentModificationException":并发修改异常
异常描述:
    使用迭代器去遍历元素,不能使用集合对象去操作元素,否则就出现并发修改异常!
解决方案:
     1)使用迭代器去遍历,迭代器添加元素--->List的特有遍历方式ListIterator有添加
     2)使用集合遍历,集合添加元素

public class List2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("java");
//方式1:使用迭代器去遍历,迭代器添加元素--->List的特有遍历方式ListIterator有添加
        ListIterator<String> lit = list.listIterator();
        while (lit.hasNext()) {
            String s = lit.next();
            if ("world".equals(s)) {
                //列表迭代器去添加元素
                lit.add("javaEE");
            }
        }
        System.out.println(list);
        System.out.println("--------------------------");

        //方式2:使用集合遍历,集合添加元素 使用List另一个特有工 E get(int index)+size()集合的普通for
        for (int x = 0;x < list.size();x++){
            String s = list.get(x);
            if ("world".equals(s)){
                list.add("javaEE");//集合添加
            }
        }
        System.out.println(list);
        System.out.println("=======================");
        //方式3:增强for(前提条件:就是集合对象不能为null)---就是替代迭代器 Iterator(只是为了简化书写格式)
        ListIterator<String> lit2 = list.listIterator();
        for (ListIterator<String> it = lit2; it.hasNext(); ) {
            String s = it.next();
            if ("world".equals(s)){
               lit2.add("javaEE");
            }
        }
        System.out.println(list);
    }
}

3.选择排序

3.1选择排序思想

思想:
    使用0角标对应的元素依次和后面角相应的元素比较,小的往前放,第一次比较完成之后,最小值就出现在最小索引处;

特点:
    时间复杂度大,不稳定;

3.2代码体现

//使用Arrays工具类直接将数组转化为字符串格式
public class ArraySout {
    public static void main(String[] args) {
        //已知数组,静态初始化
        int[] arr = {11,33,25,87,36};
        System.out.println("排序前:");
        System.out.println(Arrays.toString(arr));
     //使用的是Arrays工具类直接将数组转换字符串格式
        System.out.println("排序后:");
        selectSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void selectSort(int[] arr) {
        //外层循环比较的次数
        for (int x = 0; x < arr.length - 1; x++) {
            for (int y = x + 1; y < arr.length; y++) {
                //依次和后面角标对应的元素进行比较,小的值往前放
                if (arr[y] < arr[x]) {
                    int temp = arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                }
            }
        }
    }
}

//自定义遍历方法
ublic class ArraySout2 {
    public static void main(String[] args){
        int[] arr = {11,33,25,87,36};
        System.out.println("排序前:");
        System.out.println(printArray(arr));
        System.out.println("排序后:");
        selectSort(arr);
        System.out.println(printArray(arr));
    }
    //选择排序的方法
    public static void selectSort(int[] arr){
        //外层循环比较的次数
        for(int x = 0 ;x < arr.length-1; x++){
            for(int y = x + 1 ;y< arr.length ;y++){
                //依次和后面角标对应的元素进行比较,小的值往前放
                if(arr[y] < arr[x]){
                    int temp = arr[x] ;
                    arr[x] = arr[y] ;
                    arr[y] = temp ;
                }
            }
        }
    }

    //遍历数组的方法
    public static String printArray(int[] arr){
        //创建一个字符串缓冲区对象
        StringBuffer sb = new StringBuffer();
        sb.append("[");
        //遍历数组
        for(int x = 0 ; x < arr.length ; x++){
            if(x == arr.length-1){
                sb.append(arr[x]);
            }else{
                sb.append(arr[x]).append(", ") ;
            }
        }
        sb.append("]") ;
        return sb.toString();//StringBuffer--->String
    }
}

4.List去重

4.1List中有重复的String,去重

//方式1
//新建一个新的空集合思想,遍历以前的集合,如果以前的集合中的元素在新集合不包含,那就添加到新的集合
public class ListText1 {
    public static void main(String[] args) {
        List<String>list  = new ArrayList<>();
        //模拟添加一些重复性的字符串数据
        list.add("hello");
        list.add("hello");
        list.add("hello");
        list.add("world");
        list.add("world");
        list.add("world");
        list.add("java");
        list.add("java");

        //新建一个空的集合
        List<String>newList = new ArrayList<>();
        //遍历之前的集合:增强for循环
        for (String s:list){
            //获取到每一个元素s
            //使用新集合判断
            if (!newList.contains(s)){//新集合中不包含s的话,就直接添加到新的集合中去
                newList.add(s);
            }
        }
        for(String s:newList){//遍历新的集合
            System.out.println(s);
        }


    }
}

方式2:利用排序的核心思想:

    使用前面的角标的元素和后面角标的元素依次比较,如果后面的元素和前面的元素重复了,将后面角标对应的元素删除

 List另一个特有功能:
     public Object remove(int index):通过角标删除对应的元素!

public class ListText2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        //模拟添加一些重复性的字符串数据
        list.add("hello");
        list.add("hello");
        list.add("hello");
        list.add("world");
        list.add("world");
        list.add("world");
        list.add("java");
        list.add("java");

        //选择排序的代码
        for (int x =0;x < list.size()-1;x++){//比较次数
            for (int y = x + 1;y < list.size(); y++){//中间元素比较
                //如果后面的元素和前面的元素重复了,将后面角标对应的元素删除
                if (list.get(y).equals(list.get(x))){
                    //将后面元素删除
                    list.remove(y);
                    y--;
                }
            }
        }
        //遍历集合
        for (String s:list){
            System.out.println(s);
        }
    }
}

4.2List集合去除自定义对象

list中有重复的Student,去重,思想:建立新的集合

contains(Object e):最底层依赖于equals方法,而ArrayList里面的contains(方法)是通过indexOf(object o)方法依赖的equals方法,而这个equal的是Object的方法;Object的equal的方法是比较地址值是否相同;
        public boolean equals(Object obj) {
                   return (this == obj);
                }
        
    如果不重写这个方法,那学生的地址值不同,需要开辟新的堆内存;
    所以自定义对象的类必须重写equal方法;而且equals方法重写的时候建议重写hashCode方法

//学生类
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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    //重写equals和hashCode

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                name.equals(student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class List3 {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        Student s1 = new Student("刘备",22);
        Student s2 = new Student("张飞",32);
        Student s3 = new Student("关羽",40);
        Student s4 = new Student("黄忠",18);
        Student s5 = new Student("刘备",22);

        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        list.add(s5);
        //建立一个新的空集合
        List<Student> newList = new ArrayList<>();
        //遍历之前的集合
        for (Student a :list){
            //获取s对象以前的元素
            //如果新集合不包含这个学生对象,添加到新集合
            if (!newList.contains(a)){
                newList.add(a);
            }
        }
        //遍历新的集合
        for (Student student:newList){
            System.out.println(student.getName()+"----"+student.getAge());
        }
    }
}