新手上路之容器ArrayList遍历总结 笔记

                      **ArrayList遍历**

容器概念

  之前学的数组(优缺点)是有限个类型相同的变量的集合,是一种简单的线性队列,可在其中存放基本数据类型或对象...,可看成是容器.
  虽然它的效率高,比如查找,但是数组的长度一旦定下来,就不可更改了,就不能随着数据的添加而动态增加长度,不可避免会超出长度报空指针异常.
  我们的需求: 1. 灵活 2. 随时扩容装载对象, 容器正是我们想要的,容器的底层是利用数组实现的,其作用:也就有类似数组的特性,必须是引用类型或对象(JavaBean...)相同的变量的集合(存储相同特征的多个数据).

API方法摘要

 需要用到的类: java.util 
                         类 ArrayList<E>
 方法摘要
       boolean add(E e) 
      将指定的元素添加到此列表的尾部。 

       void add(int index, E element) 
      将指定的元素插入此列表中的指定位置。 

      E get(int index) 
      返回此列表中指定位置上的元素。 

      E set(int index, E element) 
      用指定的元素替代此列表中指定位置上的元素。 

代码一刻

引用类型的使用姿势

public class ListTry {

    public static void main(String[] args) {
        // ArrayList可以是泛型
        // 里面存储的相同类型的数据 类似数组的概念
        // 底层是数组实现的
        List<String> list = new ArrayList<String>();

        // 有序添加 可重复
        list.add("徐凤年");
        list.add("徐凤年");
        list.add("徐凤年");
        list.add("徐巧");
        list.add("徐胭脂");
        list.add("徐龙象");
        list.add("白素");

        // 使用迭代器,推荐,都是独立的
        // 好比,每次上车投币,司机只管开车相关的操作,不关心其他的
        // 投币的事交给专门的售票员维护
/*      Iterator it = list.iterator();

        //建议使用while 看上去简单明了
        while(it.hasNext()){
            String ele = (String) it.next();
            System.out.println(ele);
        }*/

        // for循环 + get
/*      for (int i = 0; i < list.size(); i++) {
            String ele = list.get(i);
            System.out.println(ele);
        }*/

        list.remove(2);
        list.set(2, "徐小乐");
        // foreach实现遍历
        // 其底层使用的也是利用迭代器实现的
        for(String list2 : list){
            System.out.println(list2);
        }

        System.out.println("-----------------");
        // 得到下标为0的值
        System.out.println(list.get(0));

        // 得到其值的大小
        System.out.println(list.size());

    }

代码结果如下:
徐凤年
徐凤年
徐小乐
徐胭脂
徐龙象
白素
- - - - - - - - - - - - - - - - -
徐凤年
6

对象(JavaBean)使用姿势

     先定义一个MyList的类(MyList):

    // javaBean
    public class MyList {
       private Integer id;
       private String userName;


         // 有参的构造是我们偷懒助手
           public MyList(Integer id, String userName) {
            super();
            this.id = id;
            this.userName = userName;
           }
            public MyList() {
                super();
                // TODO Auto-generated constructor stub
            }
        public Integer getId() {
                return id;
            }
        public void setId(Integer id) {
            this.id = id;
        }
        public String getUserName() {
            return userName;
        }
        public void setUserName(String userName) {
            this.userName = userName;
        }



    }

在定义一个ListTry1 类进行测试:

public class ListTry1 {
    public static void main(String[] args) {
        List<MyList> list = new ArrayList<>();      
        // 如果是一次性消费的话,匿名更适合我们
        //MyList myList = new MyList();
        list.add(new MyList(1,"徐凤年"));
        list.add(new MyList(2, "王者"));
        list.add(new MyList(3, "唔明"));      
        // 对其进行遍历
        // 利用迭代器进行实现
/*      Iterator<MyList> lt = list.iterator();  
        while (lt.hasNext()) {
            MyList myList = lt.next();
            System.out.println(myList.getId() + "<---------->" + myList.getUserName());
        }*/     
        // 利用for + get 
/*      for (int i = 0; i < list.size(); i++) {
            MyList myList = list.get(i);
            System.out.println(myList.getId() + "<------>" + myList.getUserName());

        }*/
        list.remove(1);
        list.set(1, new MyList(4, "亏了没"));
        // 利用foreach 遍历 javaBean
        for(MyList lMyList: list){
            System.out.println(lMyList.getId() + "<------->" + lMyList.getUserName());
        }

    }
}

结果如下:
1<——->徐凤年
4<——->亏了没

题外话(总结)

     ArrayList: 集中统一处理多个对象 ，底层:数组
        增: add(E) add(int,E)
        遍历: 迭代器 、for+get(索引)  foreach
        删:remove(int) remove(E)
        改:set(int,E)
        查:size() get(int)
        有不足之处,请路过的大牛多多指教.