Java新篇章之集合

day-08

集合

初始集合

集合的优点：

集合的长度可以修改

可以存储不同类型的基本数值

可以存储对象

jdk初代集合为 Vector，后因需求激增子类接口，初学掌握 Collection 接口

Collection 接口的实现类暂时学习 List 类和 Set 类

List 类 ---> [特点：有序，可以索引]

默认根据地址判断两个对象是否重复，可以自己建立重复的依据，重写 equals 方法

Vection : 数组

ArrayList ：数组结构，查询快，增删慢

LinkedList ：链表结构，查询慢，增删快

Set 类 ---> [特点：无序，不重复元素]

HashSet ：哈希结构，查询快

内部存储元素是辉县根据 hashCode 算出对象的哈希值，如果哈希值不同，直接存储元素；如果哈希值相同，则比较对象的内容（ equals ），如果对象的内容相同，则认为是相同元素，如果内容不同，则通过拉链法存储元素

TreeSet ：二叉树结构，自动排序

会自动对存进去的元素做自然排序，对于自定义的对象需要实现 CompareTo 接口，重写 CompareTo 方法，建立对象的比较大小方法

默认的排序是根据 CompareTo 方法所返回的 int 类型的值决定

如果返回 0 ，代表元素相同；

如果返回正数，代表当前对象比传入参数对象小；

如果返回负数，代表当前对象比传入参数对象大；

如果是自定义对象，最好是将对象的属性全比较一次，分清主次

集合的基本函数

 import java.util.ArrayList;
 import java.util.Collection;
 
 //集合
 //基本方法操作
 public class Demo14 {
     public static void main(String[] args) {
         //创建集合对象  用 ArrayList 创建的对象初始容量为 10 
         Collection c = new ArrayList();
         //往集合中添加元素   添加的元素都是对象
         c.add("12asdf");
         c.add("dkfjs");
         c.add(1);
         System.out.println(c);
         
 //      判断元素是否存在，存在为 true ，不存在为 false 
         boolean v = c.contains("sdfsdf");
         System.out.println(v);
         
 //      判断集合是否为空
         boolean t = c.isEmpty();
         System.out.println(t);
         
 //      判断集合中的个数
         int i = c.size();
         System.out.println(i);
         
 //      清空元素
         c.clear();
         System.out.println(c);
                 
     }
 }

集合的增删查改

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
 
 public class Demo15 {
     public static void main(String[] args) {
         Collection co = new ArrayList();
         List ct = new ArrayList();
         
         //增
         co.add("天晴了");
         co.add("洗衣服了");
         co.add("心情也变好了");
         co.add(1);
         co.add('a');
         co.add("null");
         System.out.println("co集合为" + co);
         ct.add("这是第二个容器");
         ct.add("今天是美好的一天");
         ct.addAll(co);
         System.out.println("ct集合为" + ct);
         
         
         //删
         co.remove("元气满满");      //删除不存在的元素
         System.out.println(co);
         co.remove("洗衣服了");      //删除存在的元素
         System.out.println(co);
 //      co.clear();
 //      System.out.println(co);
         
         //查
         
 //      获取集合
 //      先获取迭代器（遍历的工具）
         Iterator it = co.iterator();
         Iterator ie = ct.iterator();
 //      it.hasNext  boolean 类型
 //      it.next     E       返回迭代的下一个元素
         //1.迭代器查找
         System.out.println("=============
这是 co 集合");
         while(it.hasNext()) {
             System.out.println(it.next());
         }
         System.out.println("===========
这是 ct 集合");
         while(ie.hasNext()) {
             System.out.println(ie.next());
         }
         //2. for 循环迭代
         System.out.println("=============
这是 co 集合");
         for(Iterator ite = co.iterator();ite.hasNext();) {
             System.out.println(ite.next());
         }
 
         System.out.println("===========
这是 ct 集合");
         for(Iterator iq = co.iterator();iq.hasNext();) {
             System.out.println(iq.next());
         }
 //      改：往下看       
     }
 
 }

将对象放入集合中

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 //往集合中存储自定义对象
 
 public class Demo16 {
     public static void main(String[] args) {
 //      创建集合
         Collection c = new ArrayList();
 //      添加学生对象
         Student s = new Student("小丽",18);
 //      将引用添加到集合中
         c.add(s);
         //向上转型为 object o = new Student();
         c.add(new Student("小亮",19));
         System.out.println(c);
         
         //取出学生对象，获取学生对象的姓名
         for(Iterator i = c.iterator();i.hasNext();) {
             //接受集合对象    object 类型
             Object obj = i.next();
             //获取子类对象，向下强制转型
             Student stu = (Student)obj;
             System.out.println(stu.getName());
         }
         
 //      若往集合中传入的参数出现同名同龄的情况
 //      判断两个对象的地址是否相同
         Student s1 = new Student("小诺诺",18);
         Student s2 = new Student("小诺诺",18);
         System.out.println("两个对象是否相同" + s1.equals(s2));
         
         c.add(s1);c.add(s2);
         System.out.println(c);
     }
 
 }
 
 class Student {
     private int age;
     private String name;
     
     public Student(){}
     public Student(String name,int age) {
         this.name = name;
         this.age = age;
     }
     public int getAge() {
         return age;
     }
     public void setAge(int age) {
         this.age = age;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     @Override
     public String toString() {
         return "Stdent [age=" + age + ", name=" + name + "]";
     }
     @Override
     public boolean equals(Object obj) {
 //      比较对象地址
         if (this == obj)
             return true;
 //      如果传入的对象为空
         if (obj == null)
             return false;
 //      传入类类型不合法
         if (getClass() != obj.getClass())
             return false;
 //      传入合法参数，则比较参数是否相同
         Student other = (Student) obj;
         return this.name == other.name && this.age == other.age;
     }
 }

ArrayList 集合对引用数据类型（对象）进行增删查改

 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 
 public class Demo17 {
     public static void main(String[] args) {
 //      使用 List 操作，可以通过下标进行操作
 //      创建 List 集合
         List l = new ArrayList();
         //添加元素      
 //      在 Collection 中所有使用的方法，这个 List 都可以直接用
         l.add(new Student("大头1",12));
         l.add(new Student("大头2",12));
         l.add(1,new Student("大头3",12));         //插入
         System.out.println(l);
         
 //      删除元素
         l.remove(1);
         System.out.println(l);
             
         //查
 //      遍历元素
         for(Iterator it = l.iterator();it.hasNext();) {
             System.out.println(it.next());
         }
 //      获取其中一个元素
         System.out.println(l.get(1));
 //      遍历输出
         for(int i = 0; i < l.size(); i++) {
             System.out.println(l.get(i));
         }
         
         //改
         l.set(1, new Student("小达" , 20));
         System.out.println(l);
     
     }
 
 }

需求：若集合中存在某元素，则加入指定元素

 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 
 public class Demo18{
     public static void main(String[] args){
         //创建集合 list
         List list = new ArrayList();
         //往集合中添加元素
         list.add("啵斯喵1");
         list.add("啵斯喵2");
         list.add("啵斯喵3");
         
         //按照需求的思路：遍历集合，如果含有某元素，则往其中添加元素；
         //for(Iterator it = list.iterator();it.hasNext();){
         //    Object obj = it.next();
         //    String st = (String)obj;
         //    if(st.equals("啵斯喵2")){
         //        list.add("铲屎官");
         //    }
         //}
         //System.out.println(list);
      //以上方法会抛异常，因为线程和迭代器遍历集合发生冲突   
         
         //则将代码修改为修改集合元素
         for(Iterator it = list.iterator();it.hasNext();){
             Object ob = it.next();
             String str = (String)ob;
             if(str.equals("啵斯喵2")){
                 list.set(1,"铲屎官");
             }
         }
         System.out.println(list);
     }
 }

LinkedList 集合的增查改删

 //import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 
 public class Demo19{
     public static void main(String[] args){
         //创建集合
         LinkedList list = new LinkedList();
         
         //添加元素
         list.add("a1");
         list.add("a2");
         list.add("a3");
         System.out.println(list);
         
         //获取
         System.out.println(list.get(1));
         System.out.println(list.getLast());
         
         //删除元素
         Object obt1 = list.removeLast();
         Object obt2 = list.removeLast();
         //Object obt3 = list.removeLast();
         //发生异常      java.util.NosuchelementException
         //删除第一个元素
         Object removeFirst = list.removeFirst();
         //1.方法删除 最前|最后的元素，实现 堆栈|队列 结构
         while(!list.isEmpty())
             // isEmpty() 方法，判断集合是否为空，如果有元素，则返回false，否则返回true
         {
             list.removeLast();
             //list.removeFirst();
         }
         //2.迭代器删除下一个元素
         for(Iterator it = list.iterator();it.hasNext();){
             list.remove(it.next());
         }
         //3.常量自增删除元素
         for(int i = 0; i < list.size(); i++){
             list.remove(i);
         }
         System.out.println(list);
     }
 }

Set 集合：

HashSet 集合存储元素，保证元素的一致性

HashSet 集合采用 hash 算法，计算出元素的 hash 值之后再进行存储；如果 hash 值不同，则直接存储，如果 hash 值相同，则通过比较元素的 equals 方法，如果 equals 方法返回 ture ，则表示添加的元素已经存在，不进行存储，如果 equals 方法返回 false ，则通过拉链法进行存储；

 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Set;
 
 public class Demo20{
     public static void main(String[] args){
         //创建 hashset 集合
         HashSet hset = new HashSet();
         //往集合中添加元素
         hset.add("lili");
         hset.add("xiaoxiao");
         hset.add("haha");
         hset.add("lili");
         
         //往集合中添加对象
         set.add(new student("li",18));
         set.add(new Student("zhao",19));
         set.add(new Student("qian",20));
         set.add(new Student("sun",21));
         
         //获取元素
         for(Iterator it = set.iterator();it.hasNext();){
             System.out.println(it.next());
         }
     }
 }
 
 
 class Student{
     private int age;
     private String name;
     
     public Student(){}
     public Student(String name,int age) {
         this.name = name;
         this.age = age;
     }
 //  public int hashCode() {
 //      return 0;
 //  }
     public int getAge() {
         return age;
     }
     public void setAge(int age) {
         this.age = age;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     @Override
     public String toString() {
         return "Stdent [age=" + age + ", name=" + name + "]";
     }
     @Override
     public boolean equals(Object obj) {
         System.out.println("============");
 //      比较对象地址
         if (this == obj)
             return true;
 //      如果传入的对象为空
         if (obj == null)
             return false;
 //      传入类类型不合法
         if (getClass() != obj.getClass())
             return false;
 //      传入合法参数，则比较参数是否相同
         Student other = (Student) obj;
         return this.name == other.name && this.age == other.age;
     }
 }

TreeSet 集合：

不重复，自动排序的集合，二叉树结构

使用元素的自然顺序对元素进行排序，或者根据创建 Set 是提供的 Comparator 接口进行排序，具体取决于使用的构造方法

默认排序是： TreeSet 集合使用 add 方法时，实现类中调用 put 方法，TreeMap 中的 put 方法实现 Comparable 方法，调用 Comparable 方法排序

如果往集合中添加自定义类对象时，在添加元素排序时会出现强转异常，解决方法是：在自定义类中实现 Comparable 接口，重写 Compareto 方法，（public int compareto（））

 public class Demo21 {
     public static void main(String[] args) {
         Set set = new TreeSet();
         set.add(new Student("zhao",21));
         set.add(new Student("qian",10));
         set.add(new Student("sun",23));
         set.add(new Student("li",19));
         set.add(new Student("zhou",18));
         
         System.out.println(set);
         
         //遍历输出
         System.out.println("集合 set 的元素是：");
         for (Iterator it = set.iterator(); it.hasNext();) {
 //          Object object = (Object) xt();
             System.out.println(it.next());
         }
         
     }
 
 }
 class Student implements Comparable{
     private int age;
     private String name;
     
     public Student(){}
     public Student(String name,int age) {
         this.name = name;
         this.age = age;
     }
     public int getAge() {
         return age;
     }
     public void setAge(int age) {
         this.age = age;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     @Override
     public String toString() {
         return "Stdent [age=" + age + ", name=" + name + "]";
     }
     @Override
     public boolean equals(Object obj) {
         System.out.println("============");
 //      比较对象地址
         if (this == obj)
             return true;
 //      如果传入的对象为空
         if (obj == null)
             return false;
 //      传入类类型不合法
         if (getClass() != obj.getClass())
             return false;
 //      传入合法参数，则比较参数是否相同
         Student other = (Student) obj;
         return this.name == other.name && this.age == other.age;
     }
     @Override
     public int compareTo(Object o) {
         // TODO Auto-generated method stub
         if(!(o instanceof Student)) {
             throw new ClassCastException();
         }
         Student t = (Student)o;
         int temp = this.age - t.age;
         return temp==0?this.name.compareTo(t.name):temp;
     }
 }

每个NB的人物背后都有一段苦B的岁月，只要像SB一样坚持，就能变得NB

相关阅读:
最近写代码的风格，请帮忙分析下优缺点
 jQuery的回调管理机制（三）
jQuery的回调管理机制（二）
jQuery的回调管理机制
 iOS组件化
 iOS内存泄漏检测及分析
 iOS 路由
 iOS https抓包工作记录
 第二章算法入门
 第一章算法在计算中的作用
原文地址：https://www.cnblogs.com/liangls/p/12821028.html