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("=============\n这是 co 集合");
  while(it.hasNext()) {
  System.out.println(it.next());
  }
  System.out.println("===========\n这是 ct 集合");
  while(ie.hasNext()) {
  System.out.println(ie.next());
  }
  //2. for 循环迭代
  System.out.println("=============\n这是 co 集合");
  for(Iterator ite = co.iterator();ite.hasNext();) {
  System.out.println(ite.next());
  }
 
  System.out.println("===========\n这是 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;
  }
 }
 

 

posted @ 2020-05-03 10:39  ¡獨╰&丶殤¿  阅读(445)  评论(0编辑  收藏  举报