[2017.11.11]数据结构&List集合&泛型&JDK5

最新推荐文章于 2022-12-05 00:11:33 发布

莉莉埃文斯

最新推荐文章于 2022-12-05 00:11:33 发布

阅读量338

点赞数

文章标签：数据结构 arraylist linkedlist

本文链接：https://blog.csdn.net/Lily_Evans/article/details/78546473

版权

本文详细探讨了Java中的数据结构，包括栈、队列、数组和链表。重点讲解了List集合的ArrayList、Vector和LinkedList的特性，如底层数据结构、增删查改效率以及线程安全性。此外，文章还介绍了泛型的概念，强调其在提升程序安全性方面的作用，并简要概述了JDK5引入的特性，如增强for循环和泛型。

摘要由CSDN通过智能技术生成

数据结构之栈,队列数组和链表

1.栈和队列
数据结构之栈和队列

2.数组和链接列表
数据结构之数组和链接列表

List集合

1.List集合的子实现类的特点:

ArrayList:
底层数据结构是数组的形式,满足数组结构的特点:查询快,增删慢
从线程安全问题来看:线程不安全的,不同步,执行效率高
Vector:
底层数据结构是数组的形式,查询快,增删慢
从线程角度看:线程安全的类,同步,执行效率低
LinkedList:
底层数据结构是链接列表,特点:查询慢,增删快
从线程角度看:线程不安全的一个类,不同步,执行效率高

如果实现多线程程序,一般要是安全的类:
StringBuffer,Vector,hashtable

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

public class ArrayListDemo {

    public static void main(String[] args) {

        //创建一个ArrayList集合对象
        ArrayList array = new ArrayList() ;

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

        //遍历元素:
        //1)获取迭代器对象
        Iterator it = array.iterator() ;
        while(it.hasNext()){
            String s = (String)it.next() ;
            System.out.println(s);
        }
    }
}

4.ArrayList集合来存储自定义对象并遍历:

import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListDemo2 {

    public static void main(String[] args) {

        //创建ArrayList集合对象
        ArrayList array = new ArrayList() ;

        //创建几个学生对象
        Student s1 = new Student("高圆圆", 27) ;
        Student s2 = new Student("唐嫣", 25) ;
        Student s3 = new Student("邓超", 29) ;
        Student s4 = new Student("黄晓明", 28) ;

        //给集合添加元素
        array.add(s1) ;
        array.add(s2) ;
        array.add(s3) ;
        array.add(s4) ;



        //获取迭代器并遍历
        Iterator it = array.iterator() ;
        while(it.hasNext()){
    //java.lang.ClassCastException: org.westos_01.Student cannot be cast to java.lang.String
//          String s = (String)it.next() ;
            Student s = (Student) it.next() ;
            System.out.println(s);
        }
    }
}

public class Student {

    private String name ;
    private int age ;

    public Student() {
        super();
    }
    public Student(String name, int age) {
        super();
        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 + "]";
    }


}

5.Vector:
底层数据结构是数组的形式,查询快,增删慢
从线程角度看:线程安全的类,同步,执行效率低

特有功能:

public void addElement(E obj)——->相当于:add(Object e)

public Enumeration elements()—–>相当于:Iterator iterator() ;

Enumeration接口:向量的组件枚举有两个方法
boolean hasMoreElements():——>相当于:hasNext()
Object nextElement():———–>相当于:next();

源码:

synchronized:同步锁(多线程中讲):它就可以保证线程安全!
public synchronized void addElement(E obj) {//由同步代码块演变过来的同步方法

modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = obj;
}

6.演示:

import java.util.Enumeration;
import java.util.Vector;

public class VectorDemo {

    public static void main(String[] args) {

        //创建一个Vector集合对象
        Vector v = new Vector() ;

        //添加元素
        //public void addElement(E obj)
        v.addElement("hello");
        v.addElement("hello");
        v.addElement("world");
        v.addElement("Java");

        //public Enumeration<E> elements()----->相当于:Iterator iterator() ;
        Enumeration en = v.elements() ;
        //遍历元素
        /**
         * boolean hasMoreElements():------>相当于:hasNext()
        Object nextElement():----------->相当于:next();
         */
        while(en.hasMoreElements()){
            //获取元素
            String s = (String)en.nextElement() ;
            System.out.println(s);
        }
    }
}

7.LinkedList:
底层数据结构是链接列表,特点:查询慢,增删快
从线程角度看:线程不安全的一个类,不同步,执行效率高

特有功能:
添加功能:
public void addFirst(E e)将指定元素插入此列表的开头。
public void addLast(E e)将指定元素添加到此列表的结尾。
获取功能:
public Object getFirst()返回此列表的第一个元素
public Object getLast()返回此列表的最后一个元素。
删除功能:
public Object removeFirst()移除并返回此列表的第一个元素。
public Object removeLast()移除并返回此列表的最后一个元素。

8.演示:

import java.util.LinkedList;
public class LinkedListDemo {

    public static void main(String[] args) {

        //创建LinkedList集合
        LinkedList link = new LinkedList() ;

        //添加元素
        link.addFirst("hello") ;
        link.addFirst("world") ;
        link.addFirst("Java") ;

        //public void addFirst(E e)将指定元素插入此列表的开头
        /*link.addFirst("android") ;
        link.addLast("JavaWeb") ;*/


        /**
         * public Object getFirst()返回此列表的第一个元素
            public Object getLast()返回此列表的最后一个元素。
         */
        /*
        Object obj = link.getFirst() ;
        System.out.println(obj);
        Object obj2 = link.getLast() ;
        System.out.println(obj2);*/

        /**
         * public Object removeFirst()移除并返回此列表的第一个元素。
            public Object removeLast()移除并返回此列表的最后一个元素。
         */
        /*System.out.println("removeFirst:"+link.removeFirst());
        System.out.println("removeLast:"+link.removeLast());*/

        //输出集合
        System.out.println("link:"+link);
    }
}

9.演示:
ArrayList集合去除重复元素图解

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

/**
 * 需求:ArrayList去除集合中字符串的重复元素
 *      1)首先创建一个集合
 *      2)给集合中添加很多重复元素
 *      3)再次创建一个新集合
 *      4)获取迭代器遍历
 *      5)获取到该集合中的每一个元素
 *              判断新集合中是否包含这些有素
 *              有,不搭理它
 *              没有.说明不重复,添加进来
 *       6)遍历新集合
 * @author Apple
 */
public class ArrayListTest {

    public static void main(String[] args) {

        //1)创建一个集合
        ArrayList array = new ArrayList() ;

        //2)给集合中添加多个重复元素
        array.add("hello") ;
        array.add("hello") ;
        array.add("hello") ;
        array.add("world") ;
        array.add("world") ;
        array.add("world") ;
        array.add("Java") ;
        array.add("Java") ;
        array.add("hello") ;
        array.add("Javaweb") ;
        array.add("JavaEE") ;
        array.add("JavaEE") ;

        //3)创建一个新的集合
        ArrayList newArray = new ArrayList() ;

        //4)遍历旧集合,获取当前迭代器对象
        Iterator it = array.iterator() ;
        while(it.hasNext()){
            String s = (String) it.next() ;

            //拿到了每一个字符串元素
            //判断新集合是否包含旧集合中的元素

            if(!newArray.contains(s)){
                //不包含,就将元素直接添加到新集合中
                newArray.add(s) ;
            }
        }

        //遍历新集合
        Iterator it2 = newArray.iterator() ;
        while(it2.hasNext()){
            String s = (String) it2.next() ;
            System.out.println(s);
        }
    }
}

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

/**
 *  需求:ArrayList去除集合中字符串的重复元素,
 *          附件条件:不能创建新集合!
 */
public class ArrayListTest2 {

    public static void main(String[] args) {

        //创建一个集合,添加重复元素
        ArrayList array = new ArrayList() ;

        array.add("hello") ;
        array.add("hello") ;
        array.add("hello") ;
        array.add("world") ;
        array.add("world") ;
        array.add("world") ;
        array.add("Java") ;
        array.add("Java") ;
        array.add("hello") ;
        array.add("Javaweb") ;
        array.add("JavaEE") ;
        array.add("JavaEE") ;

//      System.out.println(array);
        /**
         * 由选择排序的逻辑想到:
         * 拿0索引对应的元素依次和后面索引对应的元素进行比较
         * 同理,1索引对应的元素和后面.....
         * 前面的索引对应的元素如果和后面索引对应的元素重复了,从集合移出后面索引的对应的元素
         */
        for(int x = 0 ;x <array.size() -1 ; x ++){
            for(int y= x +1 ; y <array.size() ;y++){
                //判断
                if(array.get(x).equals(array.get(y))){
                    array.remove(y) ;
                    y -- ;
                }
            }
        }

        //遍历集合
        Iterator it = array.iterator() ;
        while(it.hasNext()){
            String s = (String) it.next() ;
            System.out.println(s);
        }
    }
}

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

/**
 *  需求：ArrayList去除集合中自定义对象的重复值(对象的成员变量值都相同)
 *  
 *  发现问题:
 *          使用刚才创建新集合的思想,逻辑步骤和去除集合中重复的字符串是一样,但是出现了并没有将自定义对象的重复值(成员变量值一样)并没有去除掉
 *  
 *          contains()底层依赖于一个equals()方法,equals()方法是Object类的中的方法,该法默认比较的是对象的地址值是否相同,必须要重写Object中的eqauls()
 *  方法,才能比较内容是否相同;
 *          在自定义对象的类中重写Object中的equasl()方法,才能比较成员变量的值是否相同
 *  看源码:
 *  
 *          ArrayList集合的Contains()源码
 *            public boolean contains(Object o) {
                return indexOf(o) >= 0;
    }


    public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
 *  
 */
public class ArrayListTest3 {

    public static void main(String[] args) {

        //创建一个ArrayList集合对象
        ArrayList array = new ArrayList() ;

        //2)创建学生对象
        Student s1 = new Student("高圆圆", 27) ;
        Student s2 = new Student("高圆圆", 20) ;
        Student s3 = new Student("邓超", 29) ;
        Student s4 = new Student("邓超", 25) ;
        Student s5 = new Student("黄晓明", 30) ;
        Student s6 = new Student("高圆圆", 27) ;

        //将学生对象添加到array集合中
        array.add(s1) ;
        array.add(s2) ;
        array.add(s3) ;
        array.add(s4) ;
        array.add(s5) ;
        array.add(s6) ;

        //3)创建一个新集合
        ArrayList newArray = new ArrayList() ;

        //遍历旧集合,获取迭代器对象
        Iterator it = array.iterator() ;
        while(it.hasNext()){
            Student s = (Student) it.next() ;

            //判断新集合中是否包含这些对象
            if(!newArray.contains(s)){
                //不包含的对象才能添加新集合
                newArray.add(s) ;
            }
        }

        //遍历新集合
        Iterator it2 = newArray.iterator() ;
        while(it2.hasNext()){
            Student s = (Student) it2.next() ;
            System.out.println(s.getName()+"---"+s.getAge());
        }
    }
}

10.LinkedList

import java.util.Iterator;
import java.util.LinkedList;

//需求:使用LinkedList模拟一个栈结构的特点
    //表达的意思:自定义栈集合类,然后使用LinkedList的一些特有功能模拟栈结构特点
public class LinkedListDemo {

    public static void main(String[] args) {


        //创建LinkedList集合的对象
        LinkedList link = new LinkedList() ;
        //LinkedList集合的特有功能:addFirst(Object e) 
        //栈结构的特点:先进后出
        link.addFirst("hello") ;
        link.addFirst("world") ;
        link.addFirst("java") ;

        Iterator it = link.iterator() ;
        while(it.hasNext()){
            String s = (String)it.next() ;
            System.out.println(s);
        }
    }
}

11.演示:

import java.util.LinkedList;

/**
 * 自定义的栈集合类
 */
public class MyStack {

    //成员变量
    private LinkedList link ;

    //无参构造
    //通过无参进行LinkedList集合对象 的创建
    public MyStack(){
        link = new LinkedList() ;
    }

    //添加功能
    public void add(Object obj){
        link.addFirst(obj) ;//向集合中列表插入到第一个元素
    }


    //获取功能
    public Object get(){
        return link.removeFirst() ;//删除集合列表中的第一个元素,返回值是被删除的元素
    }

    //定义判断集合是否为空
    public boolean isEmpty(){
        return link.isEmpty() ;
    }
}

/**
 * 自定义栈集合的测试类
 */
public class MyStackDemo {

    public static void main(String[] args) {

        //创建自定义栈集合类的对象
        MyStack ms = new MyStack() ;

        //调用添加功能
        ms.add("hello") ;//link.addFier("hello")
        ms.add("world") ;
        ms.add("java") ;

        //当前栈集合中有元素了
        //获取集合集合中的元素
    /*  System.out.println(ms.get());
        System.out.println(ms.get());
        System.out.println(ms.get());
        //java.util.NoSuchElementException:没有这样元素的异常
        System.out.println(ms.get());*/

        //给当前集合对象来判断:判断集合是否为空
        /*if(!ms.isEmpty()){
            System.out.println(ms.get());
        }*/

        while(!ms.isEmpty()){
            System.out.println(ms.get());
        }

    }
}

泛型

1.使用ArrayList存储元素
给ArrayList集合存储了一些元素,String类型的元素,Integer类型的元素
但是通过迭代器遍历元素,由于,系统不知道集合中存储了哪些元素,所有使用String类型接收,就会出现ClassCastException:类转换异常
这样设计不够好!
定义一个数组:字符串数组
// String[] str = new String[3] ;
// str[0] = “hello” ;
// str[1] = “world” ;
// str[2] = 100 ;
数组设计这样好处:提前告诉了开发者,这里只能装String类型的元素,Java根据数组特点—->引出:泛型

2.泛型:把数据类型的明确工作提供提前到了创建对象或者是调用方法的时期明确的一种特殊类型.参数化类型,可以像参数一样进行传递

3.格式:
<引用类型>:泛型只能放引用类型

4.演示:

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

public class GenericDemo {

    public static void main(String[] args) {

        //创建ArrayList集合对象
        ArrayList array = new ArrayList() ;

        //添加元素
        array.add("hello") ;
        array.add("world") ;
        array.add("Java");
//      array.add(new Integer(100)) ;
//      array.add(10) ;
        //相当于:array.add(Integer.valueOf(10)) ;

        //遍历集合中的元素,获取迭代器对象
        /*Iterator it = array.iterator() ;
        while(it.hasNext()){
            //java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
            String s = (String) it.next() ;
            System.out.println(s);
        }*/

        //回想:数组
//      定义一个数组:字符串数组
//      String[] str = new String[3] ;
//      str[0] = "hello" ;
//      str[1] = "world" ;
//      str[2] = 100 ;
    }
}

5.泛型好处:
1)将运行时期异常提前到了编译时期
2)解决了黄色警告线问题
3)获取数据的时候,不用强制类型转换了

6.泛型的应用:
一般情况:泛型可以应用在接口,类,或者方法上;主要用在集合中比较多!

7.演示:

import java.util.ArrayList;

public class GenericDemo2 {

    public static void main(String[] args) {

        //创建一个ArrayList集合对象
        ArrayList<String> array = new ArrayList<String>() ;//jdk7特性:泛型推断!:建议:后面永远给出类型

        //给集合中添加元素
        array.add("hello") ;
        array.add("world") ;
        array.add("java") ;
//      array.add(10) ;

        //获取迭代器对象并遍历
        Iterator<String> it = array.iterator() ;
        //遍历
        while(it.hasNext()){
            //不用强制类型转换了
            String s = it.next() ;
            System.out.println(s);
        }

    }
}

8.演示:

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

/**
 * 使用ArrayList集合存储自定义对象并遍历
 */
public class GenericDemo3 {

    public static void main(String[] args) {
        //创建一个ArrayList集合对象
        ArrayList<Student> array = new ArrayList<Student>() ;

        //创建学生对象
        Student s1 = new Student("王昭君", 20) ;
        Student s2 = new Student("貂蝉", 25) ;
        Student s3 = new Student("杨贵妃", 29) ;
        Student s4 = new Student("凤姐", 22) ;

        //添加元素
        array.add(s1) ;
        array.add(s2) ;
        array.add(s3) ;
        array.add(s4) ;

        //获取迭代器
        Iterator<Student> it = array.iterator() ;
        while(it.hasNext()){
            Student s = it.next() ;
            System.out.println(s.getName()+"---"+s.getAge());
        }
    }
}

public class Student {

    private String name ;
    private int age ;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String name, int age) {
        super();
        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;
    }   
}

9.泛型可以提供程序的安全性!
早期的时候,用Object类型代表任意的类型
向上转型是不会出现问题的,但是向下转型的时候,由于隐藏了类型转换,导致出现错误!
JDK5以后,提供了泛型可以解决程序的安全性

10.演示:

public class ObjectToolDemo {

    public static void main(String[] args) {

        //创建ObjectTool对象
        ObjectTool ot = new ObjectTool() ;
        //设置数据
        ot.setObj(27) ;//Object obj = new Integer(27):向上转型
        //获取
        Integer i = (Integer) ot.getObj() ;//向下转型
        System.out.println("年龄是:"+i);


        ObjectTool ot2 = new ObjectTool() ;
        //设置
        ot2.setObj("高圆圆") ;//Object obj = new String("高圆圆") ;
        //获取
        String str = (String) ot2.getObj() ;//类型转换了:向下转型:隐藏了类型转换
        System.out.println("姓名是:"+str);

        System.out.println("-------------------------------");

        ObjectTool ot3 = new ObjectTool() ;
        ot3.setObj("邓超") ;
        //java.lang.ClassCastException
        Integer ii = (Integer) ot3.getObj() ;//强制类型转换的接收类型不匹配:程序不安全
        System.out.println("姓名是:"+ii);
    }
}

public class ObjectTool {

    private Object obj ;

    //获取
    public Object getObj(){
        return obj ;
    }

    //设置
    public void setObj(Object obj){//Object obj = new Integer(27) ; //向上转型
        this.obj = obj ;
    }
}

11.演示:

//工具类
//使用泛型:将泛型定义在类上:解决刚才可能出现错误
//实际开发中根据具体类型在测试中书写
public class ObjectTool<T> {

    private T obj;


    //获取
    public T getObj(){
        return obj ;
    }

    //设置
    public void setObj(T obj){
        this.obj = obj ;
    }
}

//测试类
public class ObjectToolDemo {

    public static void main(String[] args) {

        //创建ObjectTool<T>对象
        ObjectTool<String> ot = new ObjectTool<String>() ;
        //设置数据
        ot.setObj("高圆圆") ;
        //获取数据
        //编译都通过不了
//      Integer i = ot.getObj() ; 由于给类上加入了泛型,在实际测试中,给定了数据类型,获取数据的时候就必须应该类型来接收,否则不匹配
        String name = ot.getObj() ;
        System.out.println("姓名是:" +name);

        //创建对象
        ObjectTool<Integer> ot2 = new ObjectTool<Integer>() ;
        //设置数据
        ot2.setObj(27) ;

        //获取数据
//      String s = ot2.getObj() ;
        Integer i = ot2.getObj() ;
        System.out.println("年龄是:"+i);
    }
}

12.演示:

//在工具类中定义几个成员方法
/*public class ObjectTool<T> {

    //形式参数是String
    public void show(String s){
        System.out.println(s);
    }

    //形式参数是Integer类型
    public void show(Integer i){
        System.out.println(i);
    }

    public void show(Boolean b){
        System.out.println(b);
    }

    public void show(T t){
        System.out.println(t);
    }

}*/


public class ObjectTool{

    //将泛型定义在方法上
    public <T> void show(T t){
        System.out.println(t);
    }
}

//测试类
public class ObjectToolDemo {

        public static void main(String[] args) {

/*//            创建工具类对象
            ObjectTool ot = new ObjectTool() ;
            ot.show("hello") ;
            ot.show(100) ;
            ot.show(true) ;*/

        /*  ObjectTool<String> ot1 = new ObjectTool<String>() ;
            ot1.show("hello") ;

            ObjectTool<Integer> ot2 = new ObjectTool<Integer>() ;
            ot2.show(100) ;

            ObjectTool<Boolean> ot3 = new ObjectTool<Boolean>() ;
            ot3.show(true) ;*/

            //泛型可以定义在方法上吗?   public <T> void show(T t){}

            //创建工具类对象
            ObjectTool ot = new ObjectTool() ;
            ot.show("hello") ;
            ot.show(true) ;
            ot.show(100) ;
        }
}

13.演示:

//接口加入了泛型:
//第一种情况:接口的子实现类已经知道传递的是什么数据类型
/*public class InterImpl<String> implements Inter<String> {

    @Override
    public void show(String t) {
        System.out.println(t);
    }

}*/


//第二种情况:接口的子实现类在实现接口的时候,不知道具体的数据类型是什么
//在测试类的时候,传入具体数据类型

//面向接口编程

//JavaEE:Sping框架 :AOP:面向切面编程
public class InterImpl<T> implements Inter<T>{

    @Override
    public void show(T t) {
        System.out.println(t);
    }


}

//把泛型定义在接口上
public interface Inter<T> {

    public abstract void show(T t) ;
}

//测试类
public class InterDemo {

    public static void main(String[] args) {
        //创建接口对象
        //第一种情况的测试
        Inter<String> i = new InterImpl<String>() ;
        i.show("hello") ;

        System.out.println("-----------------------------");

        //第二种情况:
        Inter<Integer> i2 = new InterImpl<Integer>() ;
        i2.show(27) ;

        Inter<String> i3 = new InterImpl<String>() ;
        i3.show("高圆圆") ;
    }
}

14.泛型的高级:通配符

import java.util.ArrayList;
import java.util.Collection;

public class GenericDemo {

    public static void main(String[] args) {

        //创建Collection集合的对象
        //最起码:前后的数据类型保持一致
//      Collection<Object> c1 = new ArrayList<Animal>() ;
//      Collection<Object> c2 = new ArrayList<Cat>() ;
//      Collection<Object> c3 = new ArrayList<Dog>() ;
        Collection<Object> c3 = new ArrayList<Object>() ;


        // <?> :可以是任意类型,包括Object类型以及任意的Java类
        Collection<?> c4 = new ArrayList<Object>() ;
        Collection<?> c5 = new ArrayList<Animal>() ;
        Collection<?> c6 = new ArrayList<Cat>() ;
        Collection<?> c7 = new ArrayList<Dog>() ;

        //<? extends E>:向下限定,E类型以及E类型的子类
        Collection<? extends Object> c8 = new ArrayList<Object>() ;
        Collection<? extends Animal> c9 = new ArrayList<Animal>() ;
//      Collection<? extends Animal> c10 = new ArrayList<Object>() ;
        Collection<? extends Object> c11 = new ArrayList<Cat>() ;

        //<? super E>:向上限定,E类型以及E类型的父类
        Collection<? super Animal> c12 = new ArrayList<Object>() ;
        Collection<? super Animal> c13 = new ArrayList<Animal>() ;
//      Collection<? super Animal> c14 = new ArrayList<Dog>() ;
    }
}

//自定义两个类
class Animal{

}

class Cat extends Animal{

}
class Dog extends Animal{

}

JDK5

1.JDK5以后提供了很多特性:
泛型,增强for循环,可变参数,静态导入,自动拆装箱,枚举等的呢过

2.增强for循环

书写格式:
for(集合或者数组中的数据类型变量名:集合或者数组的对象名){
输出变量名;
}
增强for循环的弊端:
遍历数组或者集合的时候,数组对象或者集合对象不能为null
如果对象为空,一般加上非空判断

增强for循环的出现就是为了替代迭代器遍历集合的,以后开发中就是用增强for遍历元素

3.演示:

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

public class ForDemo {

    public static void main(String[] args) {

        //定义一个数组,静态初始化
        int[] arr = {11,22,33,44,55} ;

        //普通for循环的遍历
        for(int x = 0 ; x < arr.length ; x ++){
            System.out.println(arr[x]);
        }

        System.out.println("---------------------");

        //使用增强for遍历
        for(int i :arr){
            System.out.println(i);
        }

        System.out.println("-------------------");

        //定义一个字符串数组,并遍历
        String[] strArray = {"hello","world","java"};
        //直接使用增强for循环
        for(String s : strArray){
            System.out.println(s);
        }
        System.out.println("-------------------");
        //创建ArrayList集合对象,添加并遍历元素
        ArrayList<String> array = new ArrayList<String>() ;
        //添加元素
        array.add("hello") ;
        array.add("world") ;
        array.add("java") ;

        //之前:迭代器遍历
        /*Iterator<String> it = array.iterator() ;
        while(it.hasNext()){
            String s = it.next() ;
            //判断当前集合中是否有"world",如果有就添加元素
            //java.util.ConcurrentModificationException
            if("world".equals(s)){
                //使用集合添加元素
                array.add("javaee") ;
            }

        }*/

        //使用增强for遍历该集合
        for(String s :array){
            //获取到每一个元素
            //java.util.ConcurrentModificationException
            ////判断当前集合中是否有"world",如果有就添加元素
            if("world".equals(s)){
                array.add("javaee") ;
            }
        }

        System.out.println("-------------------");

    /*  array = null ;
        //java.lang.NullPointerException:空指针异常
        if(array!=null){
            //增强for循环
            for(String s:array){
                System.out.println(s);
            }
        }*/

    }
}

4.使用ArrayList集合存储自定义对象并遍历
1)toArray()
2)Collection集合的迭代器:Iterator iterator();
3)List集合的迭代器:ListIterator listiterator();
4)普通for循环:size()和get(int index)相结合
5)增强for循环

5.演示:

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

public class ForDemo2 {

    public static void main(String[] args) {

        // 创建ArrayList集合
        ArrayList<Student> array = new ArrayList<Student>();

        // 创建学生对象
        Student s1 = new Student("高圆圆", 27);
        Student s2 = new Student("高圆圆", 20);
        Student s3 = new Student("邓超", 29);
        Student s4 = new Student("邓超", 25);

        // 给集合中添加元素
        array.add(s1) ;
        array.add(s2) ;
        array.add(s3) ;
        array.add(s4) ;

        //普通for循环:size()和get(int index)相结合
        for(int x =0 ; x < array.size() ; x ++){
            Student s = array.get(x) ;
            System.out.println(s.getName()+"---"+s.getAge());
        }

        System.out.println("-----------------------");

        //Collection集合的迭代器:Iterator iterator();
        Iterator<Student> it = array.iterator() ;
        while(it.hasNext()){
            Student s = it.next() ;
            System.out.println(s.getName()+"----"+s.getAge());
        }

        System.out.println("-----------------------");

        //增强for遍历
        for(Student s : array){
            System.out.println(s.getName()+"----"+s.getAge());
        }
    }
}

public class Student {

    private String name ;
    private int age ;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String name, int age) {
        super();
        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;
    }
}

6.集合的嵌套遍历:

7.演示:

import java.util.ArrayList;

/**
 * 假设有一个Java班,看成一个容器,这个容器里面有很多学生
 * ArrayList<Student>,但是又不止一个Java班,
 * 大的集合:ArrayList<ArrayList<Student>>
 * 集合的嵌套遍历
 * @author Apple
 */
public class ArrayListTest {

    public static void main(String[] args) {

        // 创建一个大集合的对象
        ArrayList<ArrayList<Student>> bigArray = new ArrayList<ArrayList<Student>>();

        //创建第一个子集合对象ArrayList<Student>
        ArrayList<Student> firstArray = new ArrayList<Student>() ;

        //创建学生对象
        Student s1 = new Student("唐僧", 30) ;
        Student s2 = new Student("猪八戒", 22) ;
        Student s3 = new Student("孙悟空", 26) ;

        //给第一个集合中添加元素
        firstArray.add(s1) ;
        firstArray.add(s2) ;
        firstArray.add(s3) ;

        //将第一个子集合添加到大集合中
        bigArray.add(firstArray) ;

        //创建第二个子集合对象
        ArrayList<Student> secondArray = new ArrayList<Student>() ;

        //创建学生对象
        Student s4 = new Student("高圆圆", 30) ;
        Student s5 = new Student("邓超", 22) ;
        Student s6 = new Student("朱亚文", 26) ;

        //给第二个子集合中添加元素
        secondArray.add(s4) ;
        secondArray.add(s5) ;
        secondArray.add(s6) ;

        //将第二个子集合添加到大集合中
        bigArray.add(secondArray) ;

        //创建第二个子集合对象
        ArrayList<Student> thirdArray = new ArrayList<Student>() ;

        //创建学生对象
        Student s7 = new Student("高圆圆", 30) ;
        Student s8 = new Student("邓超", 22) ;
        Student s9 = new Student("朱亚文", 26) ;

        //给第二个子集合中添加元素
        thirdArray.add(s7) ;
        thirdArray.add(s8) ;
        thirdArray.add(s9) ;


        //将第二个子集合添加到大集合中
        bigArray.add(thirdArray) ;


        //遍历大集合
        //增强for遍历
        //ArrrayList<ArrayList<student>>
        for(ArrayList<Student> array :bigArray){
            //子集合:ArrayList<Student>
            for(Student s : array){
                System.out.println(s.getName()+"---"+s.getAge());
            }
        }
    }
}

public class Student {

    private String name ;
    private int age ;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String name, int age) {
        super();
        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;
    }
}