java基础------解决移位问题

集合底层是数组当删除一个元素时会发生移位 这是由于数组特性决定的谁都无法改变，要是有两个相同的元素时他就会发生错误

Student类

package 集合应用;

/**
 * @author fanlan
 * @version 1.0
 * @date 2020/4/10 11:04
 */
public class Student {
    /*
    * 需求：
    *   1.添加name score
    *   2.人数
    *   3.删除
    *   4.修改
    *   5.判断
    * */
    //声明属性
    private String name;
    private  int score;

    //创建无参构造方法
    public Student(){

    }
    //创建有参构造方法
    public Student(String name,int score){
        this.name=name;
        this.score=score;
    }
    //set get 方法
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public int getScore() {
        return score;
    }
}

测试类

package 集合应用;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * @author fanlan
 * @version 1.0
 * @date 2020/4/10 11:11
 */
public class Test_Student {
    public static void main(String[] args) {
        /*
        * 需求:
        *   1.创建5个对象
        *   2.将对象放到集合当中
        *
        * */
        //创建5 对象
        Student s_1=new Student("杨幂",100);
        Student s_2=new Student("张杰",90);
        Student s_22=new Student("张杰",90);
        Student s_3=new Student("bady",80);
        Student s_4=new Student("婉儿",85);
        Student s_5=new Student("上官",50);

        //声明集合
        List<Student>list=new ArrayList<Student>();

        //添加对象
        list.add(s_1);
        list.add(s_2);
        list.add(s_22);
        list.add(s_3);
        list.add(s_4);
        list.add(s_5);

        //输出集合当中有几个元素size
        int num =list.size();
        System.out.println("当前对象有："+num+"个");

        /*//删除张杰这个对象
        for(int i=0;i<list.size();i++){
            //获取集合当中 对象，成绩
            //list.get(i);
            if (list.get(i).getName().equals("张杰")){
                list.remove(i);
            }
        }
        //遍历集合
        for (Student student : list) {
            System.out.println("name:"+student.getName()+"-score:"+student.getScore());
            *//*当前对象有：5个
                name:杨幂-score:100
                name:bady-score:80
                name:婉儿-score:85
                name:上官-score:50
            * *//*

        }*/
        /*
        * 虽然上面的这种方式看到结果达到了我们所想的样子但是集合底层是数组当删除一个元素时会发生移位，
        * 这是由于数组特性决定的谁都无法改变，要是有两个相同的元素时他就会发生错误
        *   当前对象有：6个
            name:杨幂-score:100
            name:张杰-score:90
            name:bady-score:80
            name:婉儿-score:85
            name:上官-score:50
            当前的原因就是因为移位
            * 优化方案有两种:
            *   1.从后向前（这种将会避免发生漏删错误）
            *   2.迭代器
        * */
        // 1.从后向前
/*        //删除张杰这个对象
        for(int i=list.size()-1;i>=0;i--){
            //获取集合当中 对象，成绩
            //list.get(i);
            if (list.get(i).getName().equals("张杰")){
                list.remove(i);
            }
        }
        //遍历集合
        for (Student student : list) {
            System.out.println("name:"+student.getName()+"-score:"+student.getScore());
           *//* 当前对象有：6个
            name:杨幂-score:100
            name:bady-score:80
            name:婉儿-score:85
            name:上官-score:50*//*
        }*/
        //2.迭代器
        Iterator<Student>iterator =list.iterator();
        //判断迭代器当中是否有元素
         //iterator.hasNext();
        while(iterator.hasNext()){
            //获取迭代器中元素
            //iterator.next();
            if (iterator.next().getName().equals("张杰")){
                iterator.remove();
            }
        }
        //遍历集合
        for (Student student : list) {
            //System.out.println("name:"+student.getName()+"-score:"+student.getScore());
           /* 当前对象有：6个
            name:杨幂-score:100
            name:bady-score:80
            name:婉儿-score:85
            name:上官-score:50*/
        }
        //修改杨幂成绩为90
        for (int i=0;i<list.size();i++){
            //获取集合当中name score
            //list.get(i);
            if (list.get(i).getName().equals("杨幂")){
                list.get(i).setScore(90);

            }
        }
        //遍历集合
        for (Student student : list) {
            System.out.println("name:"+student.getName()+"-score:"+student.getScore());
        /*            当前对象有：6个
            name:杨幂-score:90
            name:bady-score:80
            name:婉儿-score:85
            name:上官-score:50*/
        }
        //判断不及格的
        for(int i=0;i<list.size();i++){
            //获取集合当中name score
            //list.get(i);
            if (list.get(i).getScore()<60){
                list.get(i).getScore();
                System.out.println("不及格"+list.get(i).getScore()+"姓名"+list.get(i).getName());
//                不及格50姓名上官
            }

        }
   }
}

总结

当遇到集合移位问题时：

优化方案有两种:

         1.从后向前（这种将会避免发生漏删错误）
          2.迭代器