Java之路---Day15(Collection类)

2019-11-01-22:09:09

目录

　　1.Collection集合的概念

　　2.Collection集合常用方法

　　3.Iterator迭代器

　　4.增强for

　　5.Collection常用工具类

---

Collection集合的概念

　　●集合:集合是java中提供的一 种容器,可以用来存储多个数据。

　　集合和数组既然都是容器,它们有啥区别呢?

　　　　●数组的长度是固定的。集合的长度是可变的。

　　　　●数组中存储的是同-类型的元素.可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候,使用集合进行存储。

Collection集合常用方法

 package demosummary.collection;
 /*
    public boolean add(E e) :把给定的对象添加到当前集合中。
 　　public void clear():清空集合中所有的元素。
 　　public boolean remove(e e);把给定的对象在当前集合中删除。
 　　public boolean contains(E e) ;判断当前集合中是否包含给定的对象。
 　　public boolean isEmpty(): 判断当前集合是否为空。
 　　public int size(): 返回集合中元素的个数。
 　　public object[] toArray(): 把集合中的元素，存储到数组中。
  */
 import java.util.ArrayList;
 import java.util.Collection;

 public class CollectionTest {
     public static void main(String[] args) {

         Collection<String> str = new ArrayList<>();
         /*
             public boolean add(E e) :把给定的对象添加到当前集合中
          */
         boolean b = str.add("张三");
 //        System.out.println(b);//true
         str.add("李四");
         str.add("王五");
         str.add("钱六");
         str.add("赵七");
 //        System.out.println(str);//[张三, 李四, 王五, 钱六, 赵七]
         /*
             public boolean remove(e e);把给定的对象在当前集合中删除
          */

 //        boolean b1 = str.remove("李四");
 //        System.out.println(b1);//true
 //        System.out.println(str);//[张三, 王五, 钱六, 赵七]

         /*
         　　public boolean contains(E e) ;判断当前集合中是否包含给定的对象
          */
         boolean b2 = str.contains("孙八");
         boolean b3 = str.contains("赵七");
         System.out.println(b2);//false
         System.out.println(b3);//true

         /*
         　　public boolean isEmpty(): 判断当前集合是否为空。
          */

         boolean b4 = str.isEmpty();
         System.out.println(b4);//false

         /*
         　　public int size(): 返回集合中元素的个数
          */
         int b5 = str.size();
         System.out.println(b5);//

         /*
         　　public object[] toArray(): 把集合中的元素，存储到数组中
          */
         Object[] obj = str.toArray();
         System.out.println(obj[0]);//张三
         for (Object o : obj) {
             System.out.println(o);
         }

         /*
         　　public void clear():清空集合中所有的元素
          */
         str.clear();
         System.out.println(str);//[]
     }
 }

Iterator迭代器

　　Iterator接口

　　　　在程序开发中.经常需要遍历集合中的所有元素。针对这种需求, JDK专门提供了一个接口java.util. Iterator。Iterator 接口也是Java集合中的一员,但它与collection、Map 接口有所不同，Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问(即遍历) Collection中的元素，因此Iterator对象也被称为迭代器。

　　迭代:

　　　　即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素,如果有,就把这个元素取出来,继续再判断,如果还有就再取出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

　　Iterator接口的常用方法

　　　　public E next() :返回迭代的下一个元素。
　　　　public boolean hasNext() :如果仍有元素可以迭代,则返回true.

 package demosummary.collection;

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

 public class IteratorTest {
     public static void main(String[] args) {
         //创建一个集合
         Collection<String> obj = new ArrayList<>();
         //往集合中添加元素
         obj.add("德玛");
         obj.add("皇子");
         obj.add("德邦");
         obj.add("剑圣");
         //使用多态方式来创建实现类对象
         Iterator<String> iter = obj.iterator();
         //使用while循环来迭代集合
         while (iter.hasNext()){
             String next = iter.next();//使用迭代器原理
             System.out.println(next);
         }
     }
 }

增强for　　

　　增强for循环:底层使用的也是迭代器,使用for循环的格式,简化了迭代器的书写是JDK1.5之后出现的新特性

　　collection<E>extends Iterable<E>:所有的单列集合都可以使用增强for
　　public interface Iterable<T>实现这个接口允许对象成为 "foreach"语句的目标。
　　增强for循环:用来遍历集合和数组
　　格式:
　　　　for(集合/数组的数据类型变量名:集合名/数组名){
　　　　　　sout(变量名);

　　　　}

 package demosummary.collection;

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

 public class IteratorTest {
     public static void main(String[] args) {
         //创建一个集合
         Collection<String> obj = new ArrayList<>();
         //往集合中添加元素
         obj.add("德玛");
         obj.add("皇子");
         obj.add("德邦");
         obj.add("剑圣");
         //使用多态方式来创建实现类对象
         Iterator<String> iter = obj.iterator();
         //增强for
         for (String str : obj) {
             System.out.println(str);
         }
     }
 }

Collection常用工具类

　　java.utils.collections 是集合工具类,用来对集合进行操作。部分方法如下:
　　　　public static <T> boolean addAll(Collection<T> C，T... elements) :往集合中添加一些元素。
　　　　public static vold shuffle(List<?> 1list) :打乱顺序:打乱集合顺序。

 package demosummary.collection;

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

 /*
     　 public static <T> boolean addAll(Collection<T> C，T... elements) :往集合中添加一些元素。
 　　　　public static void shuffle(List<?> 1list) :打乱顺序:打乱集合顺序。
 　　　　public static <T> void sort(List<T> list) :将集合中元素按照默认规则排序。
 　　　　public static <T> void sort(List<T> ist, Comparator<? super T> ) :将集合中元素按照指定规则排序。
  */
 public class CollectionTools {
     public static void main(String[] args) {
         ArrayList<String> obj = new ArrayList<>();
         //一开始学的添加元素的方法
 //        obj.add("德玛");
 //        obj.add("皇子");
 //        obj.add("德邦");
 //        obj.add("剑圣");

         /*
             　 public static <T> boolean addAll(Collection<T> C，T... elements) :往集合中添加一些元素。
          */

         //用collection的方法来添加元素
         Collections.addAll(obj,"德玛","皇子","德邦","剑圣");
         System.out.println(obj);//[德玛, 皇子, 德邦, 剑圣]

         /*
         　　　　public static void shuffle(List<?> 1list) :打乱顺序:打乱集合顺序。
          */
         Collections.shuffle(obj);
         System.out.println(obj);//[皇子, 德玛, 德邦, 剑圣]

     }
 }

　　　　public static <T> void sort(List<T> list) :将集合中元素按照默认规则排序。
　　　　public static <T> void sort(List<T> ist, Comparator<? super T> ) :将集合中元素按照指定规则排序。

 package demosummary.collection;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;

 public class CollectionTools02 {
     public static void main(String[] args) {
         //创建一个集合对象
         ArrayList<Integer> obj = new ArrayList<>();
         //使用collection方法添加元素
         Collections.addAll(obj,4,3,2,1);
         //  public static <T> void sort(List<T> list) :将集合中元素按照默认规则排序。
         //默认是升序
         Collections.sort(obj);
         System.out.println(obj);//[1, 2, 3, 4]

         /*
         　　　　public static <T> void sort(List<T> ist, Comparator<? super T> ) :将集合中元素按照指定规则排序。
          */
         //创建一个集合对象
         ArrayList<Person> obj01 = new ArrayList<>();
         //往集合添加元素
         obj01.add(new Person("德玛",18));
         obj01.add(new Person("皇子",19));
         obj01.add(new Person("德邦",20));
         obj01.add(new Person("剑圣",18));
         //输出原来集合的排序
         System.out.println(obj01);
         //使用collection的方法按照指定规则排序
         Collections.sort(obj01, new Comparator<Person>() {
             @Override
             public int compare(Person o1, Person o2) {
                 //按照大小来排序
                 int result = o1.getAge()-o2.getAge();
                 if (result==0){
                     result=o1.getName().charAt(0)-o2.getName().charAt(0);
                 }
                 return result;
             }
         });
         System.out.println(obj01);
     }
 }