• JAVA集合（一）Collection接口

    集合的框架：

    前面我们保存多个数据使用的是数组。数组有不足的地方 

    数组的特点如下所示：

    （1）长度开始时必须指定，而且一旦指定，不能更改

    示例如下：

    我们创建了一个数组：int [] n=new int[3]。   

    声明数组的方式有以下两种：1。数据类型 [  ]数组名=null;  int [ ]n=null

    2.数据类型[ ]数组名；

    数组名=new 数据类型[长度 ]；(int [] n;n=new int [10])

    数组的静态初始化有两种方式，具体格式如下：

    类型 [ ]数组名 =new 类型[ ]{元素，....}

    类型 [ ]数组名={元素，元素.......}

    当我们对这个数组进行扩容的时候，我们需要创建一个新的数组，然后再把原数组拷贝过去很麻烦。

    （2）保存的必须为同一类型的元素

    （3）使用数组进行增加或者删除元素的示意代码--比较麻烦

    示例如下所示：我们有一个Person数组，

    Person[ ] pers=new Person[ 1];  //大小是1，对于这个数组增加一个新的person对象。

    我们的做法如下：

    （1）创建一个新的数组：

    Person [ ] pers2=new Person[pers.length+1];  //新创建一个数组

    （2）

    for(){}   /拷贝pers数组的元素到pers2

    (3)

    pers2[pers2.length-1]=new Person();//添加新的对象

    我们的示例代码如下所示：

    1. package com.rgf.servlet.user;
    2.  
    3. public class J {
    4.     public static void main(String[] args) {
    5.  
    6.         int[ ] pers={1,2,3,4,5}; //大小是1，对于这个数组增加一个新的person对象。
    7.         int jihe=100;
    8.         int [ ] pers2=new int[pers.length+1];
    9.            for(int i=0;i
    10.                pers2[i]=pers[i];
    11.         }
    12.         pers2[pers2.length-1]=jihe;//添加新的对象
    13.            for (int j = 0;j
    14.             System.out.println(pers2[j]);
    15.  
    16.         }
    17.     }
    18. }

    运行界面如下所示：

    集合（多种数据放在一起）：

    （1）可以动态保存任意多个对象，使用比较方便

    （2）提供了一系列方便的操作对象的方法：add、remove、set、get等

    （3）使用集合添加、删除新元素的示意代码-简洁了

    集合的框架体系：

    java的集合类很多，主要分为两大类，如图：

    Collection.java

    1. package com.rgf.jihe;
    2.  
    3. /**
    4.  * 一、集合框架的概述
    5.  * 1.集合、数组都是对多个数据进行存储操作的结构，简称java容器。
    6.  * 说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi,数据库中）
    7.  * 2.1数组在存储多个数据方面的特点：
    8.  *   >一旦初始化以后，其长度就确定了。
    9.  *   >比如：数组一旦定义好，其元素的类型1也就确定了。我们也就只能操作指定类型的数据了。
    10.  * Stirng[] arr,int [] arr1；Object [] arr2;
    11.  *  2.2数组在存储多个数据方面的缺点：
    12.  *   >一旦初始化以后，其长度就不可修改。
    13.  *   >数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
    14.  *   >获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
    15.  *   >数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。
    16.  *二、集合框架
    17.  *  1.Collection接口（单列集合，用来存储一个一个的对象）
    18.  *  set(无序不可重复）:hashset、treeset、Linkedhashset
    19.  *  list(有序可重复,动态数组）:linkedlist、Arraylist、Vector
    20.  *  2.Map接口（双列集合，用来存储一对（key - value)一对的数据）
    21.  *  hashMap、LinkedHashMap、Hashtable、properties
    22.  *  treemap
    23.  */
    24. public class ConnectionTest {
    25.  
    26. }

     collection集合为单列集合。（单列集合即为在这个集合里面放的单个的对象）

    其中，Linkedlist为链表的list,ArrayList为数组的list。

     Map集合为双列集合（双列集合放的是键值对形式的）

    集合主要是两组：双列集合（Map集合）和单列集合（Collection集合）。

    Collection接口有两个重要的子接口：Set（元素无序、不可重复的集合）和List（元素有序、可重复的集合）,他们的实现子类都是单列集合。（里面放的单个单个的元素）

    Map接口的实现子类：HashMap和TreeMap，HashTable。他们的实现子类为双列集合（里面放的为键值对，为key-value形式的值）

    我们更加形象的查看双列集合和单列集合：

    1.  //添加单列集合
    2.         ArrayList arrayList = new ArrayList();
    3.         arrayList.add("jdbc");
    4.         arrayList.add("javaweb");
    5.         HashMap hashMap = new HashMap();
    6.         //添加双列集合
    7.         hashMap.put("number1","北京");
    8.         hashMap.put("number2","上海");

    Collection接口：

    Collection接口实现类的特点：

    public interface Collection extends Iterable

    (1）Collection实现子类可以存放多个元素，每个元素可以是Object

    (2)有些Collection的实现类，可以存放重复的元素（List)，有些不可以(Set)

    （3）有些Collection的实现类，有些是有序的（List),有些不是有序（Set)

    (4)Collection接口没有直接的实现子类，是通过它的子接口Set和List来实现的。

    Collection接口的常用方法：

    向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals().

    由于Collection接口本身不能被实例化的，我们以实现子类ArrayList来进行示例：

    1. package com.rgf.collection;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.List;
    5.  
    6. public class CollectionMethod {
    7.     @SuppressWarnings({"all"})
    8.     public static void main(String[] args) {
    9.         List list = new ArrayList();
    10.         //add：add(Object e):将元素e添加到集合coll中
    11.         list.add("jdbc");
    12.         list.add(10);//所添加的数已经不是基本数据类型，而是对象，本质是这么装的：list.add(new Integer(10))  自动装箱
    13.         list.add(true);
    14.         System.out.println("list="+list);
    15.         //remove:删除指定元素
    16.         //remove(Object o),删除的是一个对象，返回的就是一个boolean值，即为是否删除成功
    17.         //remove(int index),删除的是一个索引值，返回的是被删除的对象。
    18.         list.remove("jdbc");
    19.         System.out.println("list="+list);
    20.         list.remove(0);//删除第一个元素
    21.         System.out.println("list="+list);
    22.         //contains:查找元素是否存在（contains(Object obj):判断当前集合中是否包含obj,判断的是内容，而不是地址。String重写过了equals方法，是比较内容，如果没有重写equals方法，在调用equals的时候是调用Object里面的，里面为==。
    23.        //我们在判断时会调用obj对象所在类的equals（）。
    24.         System.out.println(list.contains(true));//返回true
    25.         System.out.println( list.contains("rgf"));//返回false
    26.         //size:获取添加的元素的个数
    27.         System.out.println(list.size());//1
    28.         //isEmpty:判断当前集合是否为空
    29.         System.out.println(list.isEmpty());
    30.         //clear:清空
    31.         list.clear();
    32.         System.out.println("list"+list);
    33.         //addAll:添加多个元素,addAll(Connection c),实现了Connection接口的类的一个对象都可以传进去
    34.        List list2 = new ArrayList();
    35.        list2.add("三国演义");
    36.        list2.add("红楼梦");
    37.         System.out.println("list2="+list2);
    38.         list.addAll(list2);
    39.         System.out.println("list="+list);
    40.         //containsAll:查找多个元素是否都存在
    41.         System.out.println(list.containsAll(list2));  //true
    42.         //removeAll:删除多个元素.以下代码为把list里面中的所有list2中的元素全部删掉，即把他们的交集删掉。
    43.         list.add("水浒传");
    44.         list.removeAll(list2);
    45.         System.out.println("list="+list);
    46.  
    47.  
    48.  
    49.     }
    50. }

    我们运行之后，如下所示：

    方法示例二：

    1. package com.rgf.jihe;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Arrays;
    5. import java.util.List;
    6. import java.util.Objects;
    7.  
    8. /**
    9.  * 一、集合框架的概述
    10.  * 1.集合、数组都是对多个数据进行存储操作的结构，简称java容器。
    11.  * 说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi,数据库中）
    12.  * 2.1数组在存储多个数据方面的特点：
    13.  *   >一旦初始化以后，其长度就确定了。
    14.  *   >比如：数组一旦定义好，其元素的类型1也就确定了。我们也就只能操作指定类型的数据了。
    15.  * Stirng[] arr,int [] arr1；Object [] arr2;
    16.  *  2.2数组在存储多个数据方面的缺点：
    17.  *   >一旦初始化以后，其长度就不可修改。
    18.  *   >数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
    19.  *   >获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
    20.  *   >数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。
    21.  *二、集合框架
    22.  *  1.Collection接口（单列集合，用来存储一个一个的对象）
    23.  *  set(无序不可重复）:hashset、treeset、Linkedhashset
    24.  *  list(有序可重复,动态数组）:linkedlist、Arraylist、Vector
    25.  *  2.Map接口（双列集合，用来存储一对（key - value)一对的数据）
    26.  *  hashMap、LinkedHashMap、Hashtable、properties
    27.  *  treemap
    28.  */
    29. public class ConnectionTest {
    30.     public static void main(String[] args) {
    31.         ArrayList list = new ArrayList();
    32.         list.add(123);
    33.         list.add(456);
    34.         list.add(new Person("Jerry",20));
    35.         ArrayList list1 = new ArrayList();
    36.         list1.add(123);
    37.         list1.add(456);
    38.         list1.add(new Person("Jerry",20));
    39.  
    40.         //retainAll(Collection coll1):获取当前集合和list1集合的交集，并返回给当前集合
    41.         list.retainAll(list1);
    42.         System.out.println(list);  //[123,
    43.  
    44.         //equals(Object obj)：要想返回true,需要当前集合和形参集合的元素都相同。
    45.         // 如果顺序不一致，也不一样，实现类ArrayList是有序的
    46.         System.out.println(list.equals(list1));
    47.  
    48.         //hashCode():返回当前对象的哈希值
    49.         System.out.println(list.hashCode());
    50.  
    51.         //集合 --->数组：toArray()
    52.         Object[] objects = list.toArray();
    53.         for (int i=0;i< objects.length;i++){
    54.             System.out.println(objects[i]);
    55.         }
    56.  
    57.  
    58.         //数组--->集合:调用Arrays类的静态方法aList()
    59.         List LIST = Arrays.asList(new String[]{"AA", "BB", "CC"});
    60.         System.out.println(LIST);
    61.  
    62.         List<int[]> ints = Arrays.asList(new int[]{123, 456});
    63.         System.out.println(ints);
    64.         System.out.println(ints.size()); //1
    65.  
    66.         List ints1 = Arrays.asList(new Integer(789),new Integer(441));
    67.         System.out.println(ints1);
    68.         System.out.println(ints1.size());
    69.  
    70.         //iterator():返回Iterator接口的实例，用于遍历集合元素。
    71.     }
    72.  
    73. }
    74. class  Person{
    75.     String name;
    76.     int age;
    77.  
    78.     public Person() {
    79.     }
    80.  
    81.     public Person(String name, int age) {
    82.         this.name = name;
    83.         this.age = age;
    84.     }
    85.  
    86.     public String getName() {
    87.         return name;
    88.     }
    89.  
    90.     public void setName(String name) {
    91.         this.name = name;
    92.     }
    93.  
    94.     public int getAge() {
    95.         return age;
    96.     }
    97.  
    98.     public void setAge(int age) {
    99.         this.age = age;
    100.     }
    101.  
    102.     @Override
    103.     public boolean equals(Object o) {
    104.         if (this == o) return true;
    105.         if (o == null || getClass() != o.getClass()) return false;
    106.  
    107.         Person person = (Person) o;
    108.  
    109.         if (age != person.age) return false;
    110.         return name != null ? name.equals(person.name) : person.name == null;
    111.     }
    112.  
    113.  
    114. }

     运行之后如下所示：

     Collection接口遍历元素方式1----使用Iterator（迭代器）

     我们可知：Collection的父接口为Iterable。

    我们查看Iterator的源码如下所示：

     我们发现Iterable里面有个很重要的方法，即为Iterator方法。

    可以通过Iterator方法返回一个Iterator对象。Iterator对象就是我们所说的迭代器对象。

    我们可以使用Iterator对象进行所有元素的一个遍历。

    只要是实现了Collection接口的子类，都可以去获取到一个Iterator（迭代器），然后用这个迭代器来遍历这个集合里面的所有对象。

    （1）Iterator对象称为迭代器，主要用于遍历Collection集合中的元素

    （2）所有实现了Collection接口的集合类都有一个Iterator（）方法，用以返回一个实现了Iterator接口的对象，既可以返回一个迭代器。

    （3）Iterator的结构：

    迭代器的执行原理：

    我们有一个竖表：

    123
    AA
    new  Date()
    1 
    2

    这个表相当于数组一样，可以把数据都存放进里面去，当我们通过Iterator方法，得到一个迭代器后，我们每次调用这个迭代器的next方法，就会往下移动 一格，每调用一次，往下移动一次，并且把这个数据取出来，直到把最后一个数据取出来之后，再往下移动之后，取不到东西从而退出。

    Iterator iterator =coll.iterator();//得到一个集合的迭代器

    //hasNext():判断是否还有下一个元素，没有会返回false（Iterator对象的一个方法）

    while(Iterator.hasNext()){   //返回false后，这个循环会结束

    //next():1指针下移2.将下移以后集合位置上的元素返回

    System.out.println(iterator.next());

    }

    我们进行查看源码：

    Iterator接口里面有个hasNext方法，hasNext方法会如果iteration有更多的元素，会返回true。没有更多的元素则会返回false。 

    其中的next()方法有两个作用：//next():1指针下移2.将下移以后集合位置上的元素返回

    Iterator接口的方法：

     注意：在调用Iterator.next（）方法之前必须要调用Iterator.hasNext().

    进行检测，若不调用，且下一条记录无效，直接调用Iterator.next()会抛出NoSuchElementException异常。

    我们发现迭代器里面有一个remove.我们进行实现如下所示：

    1. package com.rgf.jihe;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Iterator;
    5.  
    6. /**
    7.  * 集合元素的遍历操作，使用迭代器Iterator接口
    8.  * 1.内部的方法：hasNext()和next()
    9.  * 2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象
    10.  * 默认游标都在集合的第一个元素之前
    11.  * 3.内部定义了remove(),可以在遍历的时候，删除集合中的元素，此方法不同于集合直接调用remove()
    12.  *
    13.  */
    14. public class Iterator2 {
    15.     public static void main(String[] args) {
    16.         ArrayList list = new ArrayList();
    17.         list.add("123");
    18.         list.add("456");
    19.         list.add(new String("沃尔"));
    20.         //Iterator可以删除集合的元素，但是是遍历过程中通过迭代器对象的remove方法，不是集合对象的remove方法。
    21.         //如果还未调用next（）或在上一次调用next方法之后已经调用了remove方法，再调用remove都会报IllegalStateException
    22.         Iterator iterator = list.iterator();
    23.         while (iterator.hasNext()){
    24.             Object next = iterator.next();
    25.             if("沃尔".equals(next)){
    26.                 iterator.remove();
    27.         }
    28.     }
    29.         Iterator iterator1 = list.iterator();
    30.         while (iterator1.hasNext()){
    31.             System.out.println( iterator1.next());
    32.         }
    33.     }
    34. }

     运行之后如下所示：

     （4）Iterator仅用于遍历集合，并不是容器，Iterator本身并不存放对象。

    Iterator接口的实现：

    1. package com.rgf.collection;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Iterator;
    5. import java.util.List;
    6.  
    7. public class CollectionIterator {
    8.     public static void main(String[] args) {
    9.         List col = new ArrayList();
    10.         col.add(new Book("三国演义","罗贯中",52.2));
    11.         col.add(new Book("西游记","吴承恩",22.5));
    12.         col.add(new Book("红楼梦","曹雪芹",32.8));
    13.         System.out.println("col="+col);
    14.         //我们进行输出的时候发现是连着输出，但是现在我们希望一个一个进行取出。如下所示：
    15.         //先得到col对应的迭代器
    16.         Iterator iterator = col.iterator();
    17.        //此时返回iterator对象的时候，此时的指针是指在第一个对象的上面。当调用hasNext的时候，判定为true的时候，执行next,此时返回第一个数的同时，指针进行下移。之后再次调用next.
    18.         //使用while循环遍历，我们可以使用快捷键进行快速循环：itit，
    19.         // 显示所有的快捷键的快捷键：ctrl+j，我们可以查看当前的快捷模板。
    20.         while(iterator.hasNext()){ //hasNext:判断集合中是否还有下一个元素
    21.             //返回下一个元素，类型是object。
    22.             Object object = iterator.next();//取出集合中的对象
    23.             //编译类型为object，但是我们的运行类型是取决于我们真正存放的类型。
    24.             System.out.println("object="+object);
    25.         }
    26.         //当迭代器退出while循环后，这是iterator指向了最后的元素。
    27.      //   iterator.next(); //NoSuchElementException
    28.      //如果希望再次遍历，需要重置我们的迭代器。
    29. iterator=col.iterator();
    30.         System.out.println("===第二次遍历===");
    31.         while (iterator.hasNext()) {
    32.             Object next =  iterator.next();
    33.             System.out.println("next="+next);
    34.  
    35.         }
    36.     }
    37. }
    38. class Book{
    39.     private String name;
    40.     private String author;
    41.     private  double price;
    42.  
    43.     public Book(String name, String author, double price) {
    44.         this.name = name;
    45.         this.author = author;
    46.         this.price = price;
    47.     }
    48.  
    49.     public String getName() {
    50.         return name;
    51.     }
    52.  
    53.     public void setName(String name) {
    54.         this.name = name;
    55.     }
    56.  
    57.     public String getAuthor() {
    58.         return author;
    59.     }
    60.  
    61.     public void setAuthor(String author) {
    62.         this.author = author;
    63.     }
    64.  
    65.     public double getPrice() {
    66.         return price;
    67.     }
    68.  
    69.     public void setPrice(double price) {
    70.         this.price = price;
    71.     }
    72.  
    73.     @Override
    74.     public String toString() {
    75.         return "Book{" +
    76.                 "name='" + name + '\'' +
    77.                 ", author='" + author + '\'' +
    78.                 ", price=" + price +
    79.                 '}';
    80.     }
    81. }

    运行界面如下所示：

    错误使用迭代器的两种方式如下所示：

    1. package com.rgf.jihe;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Iterator;
    5.  
    6. public class Iterator1 {
    7.     public static void main(String[] args) {
    8.         ArrayList list = new ArrayList();
    9.         list.add(123);
    10.         list.add(456);
    11.         
    12.         //错误方式一：会报错，同时会间隔输出
    13.         Iterator iterator = list.iterator();
    14.         while (iterator.next()!=null){
    15.             System.out.println(iterator.next());
    16.         }
    17.         
    18.         //错误方式二：每当调用list.iterator方法，都会返回一个迭代器对象，这个迭代器的对象是新的，新的就会在数据的开头。就会一直在第一个位置
    19.         while (list.iterator().hasNext()){
    20.             System.out.println(list.iterator().next());
    21.         }
    22.     }
    23. }

     Collection接口遍历元素方式2----增强for循环

    增强for循环，可以代替iterator迭代器，特点：增强for循环就是简化版的iterator,本质一样。只能用于遍历集合或数组。

    基本语法：

    for(元素类型  元素名：集合名或数组名）{

    访问元素

    }

    我们的代码示例如下所示：

    1. package com.rgf.collection;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Iterator;
    5. import java.util.List;
    6.  
    7. public class CollectionIterator {
    8.     @SuppressWarnings({"all"})
    9.     public static void main(String[] args) {
    10.         List col = new ArrayList();
    11.         col.add(new Book("三国演义", "罗贯中", 52.2));
    12.         col.add(new Book("西游记", "吴承恩", 22.5));
    13.         col.add(new Book("红楼梦", "曹雪芹", 32.8));
    14.         //使用增强for循环
    15.         //for(元素类型 元素名称： 集合名或元素名）
    16.         for(Object book:col){
    17.             System.out.println("book="+book);
    18.         }
    19.         //1.增强for可以直接在数组上使用,也可以在Collection集合使用。
    20.         //2.增强for，它的底层仍然是迭代器
    21.         //3.可以理解成增强for循环就是简化版本的迭代器遍历
    22.         //4.快捷键方式：I
    23.         int [] arr={1,8,10,90};
    24.         for(int i:arr){
    25.             System.out.println("i="+i);
    26.         }
    27.     }
    28. }
    29. class Book{
    30.     private String name;
    31.     private String author;
    32.     private  double price;
    33.  
    34.     public Book(String name, String author, double price) {
    35.         this.name = name;
    36.         this.author = author;
    37.         this.price = price;
    38.     }
    39.  
    40.     public String getName() {
    41.         return name;
    42.     }
    43.  
    44.     public void setName(String name) {
    45.         this.name = name;
    46.     }
    47.  
    48.     public String getAuthor() {
    49.         return author;
    50.     }
    51.  
    52.     public void setAuthor(String author) {
    53.         this.author = author;
    54.     }
    55.  
    56.     public double getPrice() {
    57.         return price;
    58.     }
    59.  
    60.     public void setPrice(double price) {
    61.         this.price = price;
    62.     }
    63.  
    64.     @Override
    65.     public String toString() {
    66.         return "Book{" +
    67.                 "name='" + name + '\'' +
    68.                 ", author='" + author + '\'' +
    69.                 ", price=" + price +
    70.                 '}';
    71.     }
    72. }

    运行之后如下所示：

    增强for循环的底层仍然是迭代器，我们可以通过断点的方式进行查看：

     

    我们点击Debug进行查看：

    我们发现进入如下界面。


     

     我们发现进入的页面也是调用了Iterator,调用了hasNext的方法和next的方法。

    增强for循环内部仍然使用的是迭代器Iterator。

    我们进行如下练习：

    1. package com.rgf.jihe;
    2.  
    3. public class IteratorE {
    4.     public static void main(String[] args) {
    5.       String[] arr=new String[]{"MM", "MM", "MM"};
    6.       //方式一：普通for赋值,这种方式可以将值进行修改
    7.       for (int i=0;i
    8.           arr[i]="GG";
    9.         }
    10.         for (String i:arr){
    11.             System.out.println(i);
    12.         }
    13.  
    14.         String[] arr1=new String[]{"MM", "MM", "MM"};
    15.       //方式二：增强for循环,此时我们输出仍然为MM,因为在增强for循环中，我们相当于把arr里面的数据先取出来，然后赋值给s，我们修改的是s,
    16.         //而不是arr。所以仍然为MM.
    17.         for(String s:arr1){
    18.             s="GG";
    19.         }
    20.  
    21.       for (String i:arr1){
    22.           System.out.println(i);
    23.       }
    24.  
    25.     }
    26. }

    我们运行之后如下所示：

     

     小测试:

    编写程序CollectionExercise.java

    1.创建3个Dog(name,age)对象，放入到ArrayList中，赋给List引用

    2.用迭代器和增强for循环两种方式来遍历

    3.重写Dog的toString方法，输出name和age。

    我们首先创建：

    1. package com.rgf.collection;
    2.  
    3. public class CollectionExercise {
    4.     public static void main(String[] args) {
    5.         
    6.     }
    7. }

    之后编写Dog类。

    1. package com.rgf.collection;
    2.  
    3. public class CollectionExercise {
    4.     public static void main(String[] args) {
    5.  
    6.     }
    7. }
    8. class Dog{
    9.     private String name;
    10.     private int age;
    11.     
    12. }

    设置他们的构造器和getter和setter方法和toString方法：

    1. package com.rgf.collection;
    2.  
    3. public class CollectionExercise {
    4.     public static void main(String[] args) {
    5.  
    6.     }
    7. }
    8. class Dog{
    9.     private String name;
    10.     private int age;
    11.  
    12.     public Dog(String name, int age) {
    13.         this.name = name;
    14.         this.age = age;
    15.     }
    16.  
    17.     public String getName() {
    18.         return name;
    19.     }
    20.  
    21.     public void setName(String name) {
    22.         this.name = name;
    23.     }
    24.  
    25.     public int getAge() {
    26.         return age;
    27.     }
    28.  
    29.     public void setAge(int age) {
    30.         this.age = age;
    31.     }
    32.  
    33.     @Override
    34.     public String toString() {
    35.         return "Dog{" +
    36.                 "name='" + name + '\'' +
    37.                 ", age=" + age +
    38.                 '}';
    39.     }
    40. }

    之后我们进行创建集合，进行遍历输出：

    1. package com.rgf.collection;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Iterator;
    5. import java.util.List;
    6.  
    7. public class CollectionExercise {
    8.     public static void main(String[] args) {
    9.         List list = new ArrayList();
    10.         list.add(new Dog("小黑",10));
    11.         list.add(new Dog("大黄",15));
    12.         list.add(new Dog("jack",5));
    13.        //先使用增强for循环。
    14.         for (Object dog :list) {
    15.             System.out.println("dog="+dog);
    16.         }
    17.       //使用iterator迭代器
    18.         Iterator iterator = list.iterator();
    19.         while (iterator.hasNext()) {
    20.             Object dog =  iterator.next();
    21.             System.out.println("dog="+dog);
    22.         }
    23.  
    24.     }
    25. }
    26. class Dog{
    27.     private String name;
    28.     private int age;
    29.  
    30.     public Dog(String name, int age) {
    31.         this.name = name;
    32.         this.age = age;
    33.     }
    34.  
    35.     public String getName() {
    36.         return name;
    37.     }
    38.  
    39.     public void setName(String name) {
    40.         this.name = name;
    41.     }
    42.  
    43.     public int getAge() {
    44.         return age;
    45.     }
    46.  
    47.     public void setAge(int age) {
    48.         this.age = age;
    49.     }
    50.  
    51.     @Override
    52.     public String toString() {
    53.         return "Dog{" +
    54.                 "name='" + name + '\'' +
    55.                 ", age=" + age +
    56.                 '}';
    57.     }
    58. }

    运行之后如下所示：

  • 相关阅读:
    python第三方库-字符串编码工具 chardet 的使用（python3经典编程案例）
    【python】带你采集基金股票数据并作可视化操作
    java static作用
    部署高可用FastDFS集群时遇到的错误
    GoogleTest学习笔记(二）
    Python零基础入门-7 输入与输出
    Jenkins发布windows服务器jar
    【前端】vue数组去重的3种方法
    Qt在Windows上配置web assembly保姆教程
    A-Level商务模型介绍：波士顿矩阵
  • 原文地址：https://blog.csdn.net/weixin_59448049/article/details/126961199