Java基础（集合）

最新推荐文章于 2024-07-29 14:22:26 发布

指尖跳动

最新推荐文章于 2024-07-29 14:22:26 发布

阅读量284

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_25045639/article/details/78230765

版权

集合

集合大概理论：

List接口

 ArrayList：实现了可变的数组，在内存中分配连续的空间，便利元素和随机访问元素的效率比较高。
    LinkedList：采用链表储存方式，插入，删除元素时效率比较高！

set接口

 HashSet:唯一，重复，直接不能储存进去！无序的，是采用哈希吗储存的！

Collection 是层次结构根接口

List: 有序（存入和取出的顺序一致），元素都有索引（角标），储存的元素可以重复。(怎么存的元素，就怎么吧元素取出来) 　　　　　 ArrayList是List的子接口。

set: 元素不能重复，储存的元素是无序的。

一些collection允许有重复元素，而另一些则不允许。一些collection是有序的，而另一些则是无序的。

由于collection是接口，所以不能new他的对象

语法：

 Collection collection  = new Collection();
这种是语法错误的，因为 Collection 是接口，所以不能new，因为毫无意义。不能实例化
那么我们怎么new了？ 此时我们就要找他的实现对象
我们查找API 发现colletion有很多实现子类 extends collection

所有已知实现类： AbstractCollection, AbstractList, AbstractQueue, AbstractSequentialList, AbstractSet, ArrayBlockingQueue, ArrayDeque, ArrayList, AttributeList, BeanContextServicesSupport, BeanContextSupport, ConcurrentLinkedQueue, ConcurrentSkipListSet, CopyOnWriteArrayList, CopyOnWriteArraySet, DelayQueue, EnumSet, HashSet, JobStateReasons, LinkedBlockingDeque, LinkedBlockingQueue, LinkedHashSet, LinkedList, PriorityBlockingQueue, PriorityQueue, RoleList, RoleUnresolvedList, Stack, SynchronousQueue, TreeSet, Vector

Collection的使用常见方法

1：添加。 boolean add(Object obj);

boolean addAll(colecton coll);

吧这个引用类型元素添加到调用此方法的引用。

2:删除。 boolean remvoe(Object obj);

boolean removeAll(collecton coll);

删除重复的元素，保留不重复的元素

3:判断 boolean contains(Object obj);

boolean contains(collection coll); 如果列表包含指定 collection 的所有元素，则返回 true。

boolean isEmpty();判断集合中是否有元素

4:获取 int size();

iterator iterator();取出元素的方式，迭代器

5:其他 boolean retainAll(collection coll);取交集。

Object[]toString();将集合转成数组。

语法：
 //储存数据
         *ollection collection = new ArrayList();
           collection.add(100);
           collection.add("哈哈");
           collection.add(10.1);
           collection.add(false);
           System.out.println("他的长度是"+collection.size());

这个是打印他的这个集合的长度

toArray() 关键词是吧集合的内容全部转为数组；

 public class Demo3 {
     public static void main(String[]args){
     Collection collection = new ArrayList();
     Demo demo = new Demo(null,0);//此时这句话可以不写因为在集合里面new了这个类的无参构造。
     collection.add(new Demo("哈哈哈",10));
     collection.add(new Demo("嘻嘻嘻",30));
     collection.add(new Demo("啦啦啦",80));
     System.out.println("他的长度是"+collection.size());  

     Object[] obj = collection.toArray();    //因为ArrayList是实现Collection子类所以他们都是基于OBject超类
     for(int i =0;i<collection.size();i++){
        Demo demo =(Demo)obj[i]; //吧每次collection集合遍历的地址都给了demo对象名
       System.out.println(demo.getname);
       System.out.println(demo.getin);
       }
     }
 }

 class Demo{

    private String name; // private String [] name;
         private int in;//

    public Demo(String ing, int in) {
     this.ing = ing;
     this.in = in;
 }
 public String getname(){
       return name;
    }
    public void setname(String name){
       this.name = name;
    }
    public int getin(){
       return in;
    }
    public void setin(int in){
       this.in = in;
    }
 }

以下new出来的是错误的，因为name 和 in 是普通值，而在遍历数组的时候，是无法加载的，除非 private String [] name; private int[] in;

或者

 System.out.println(demo.getname());
 System.out.println(demo.getin());

后面加上();

addAll（）方法

用于：添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。

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

  class Demo1{
    public static void main(String[]args){
    Collection collection = new Arraylist();
    Collection collection1 = new Arraylist();

    collection.add("1");
    collection.add("2");
    colelction.add("3");

    collection1.add("2");
    collection1.ada("4");
    collection1.add("4");

    collection.addAll(collection1);
  //这句代码是将这个colleciton的元素添加到colleciton1里面
    System.out.println(collection);

      } 
  }

removeAll()

用于：移除此 collection 相同的元素（重复的元素），保留不相同的元素（不重复的元素）；

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

    Collection collection = new ArrayList();
    Collection collection1  = new ArrayList();

    collection.add("1");
    collection.add("2");
    collection.add("3");

    collection1.add("1");
    collection1.add("2");
    collection1.add("6");

 //   System.out.println(collection.addAll(collection1));//因为removeAll是boolean，所以返回的是布尔类型
    collection.addAll(collection1);
    System.out.println(collection);

    collection.removeAll(colleciotn1);
    System.out.println(colelciton);
    //这两句代码是 两个引用类型，在堆内存储存一样的元素时候，那么全部去掉，只留下两个堆内存中不重复的元素

    }
   }

containsAll

如果此colleciton 包含了全部的colleciton的元素，则返回true，否则返回false

 public class Demo{
  public static void main(String[]args){
   Collection collection = new ArrayList();
   Collection collection1 = new ArrayList();

   collection.add("1");
   collection.add("2");

   collection1.add("1");
   colelction1.add("2");

   collection.containsAll(collection1);
   //containsAll 如果这个包括了全部的元素，那么返回true否则就是false
       }
 }

retainAll()

用于：如果集合colleciton 去交集，删除collection不相同的元素，保留相同的元素，和remove相反

 public class dEMO {
public static void main(String[]args){
List list = new ArrayList();
List list1 = new ArrayList();
  yi(list,list1);


}
public static void yi(List<String> list,List list1){
    list.add("1");
    list.add("2");
    list.add("3");

    list1.add("6");
    list1.add("2");
    list1.add("3");

    boolean a = list.retainAll(list1);
    System.out.println(list1+"+"+list);
    System.out.println(a);
 //取交集，保留相同的元素，干掉不相同的元素

}

}

迭代器接口 Iterator()

方法摘要:

hasNext() 如果仍有元素迭代，则返回true

next() 返回迭代的下一个元素

remove() 从迭代器指向的collection中移除迭代器返回的最后一个元素（可选操作）

一般用来遍历集合内容的

返回在此collection的元素上进行迭代的迭代器。关于元素返回没有任何保证（除非此collection是某个能提供保证顺序的类实列）。

 Iterator iterator = demo.iterator();
  //这句代码是调用集合迭代器方法，为了获取集合的迭代器对象

语法如下:

 class Demo{
public static void mian(String[]args){
Collecton collection = new ArrayList();
collection.add(new Demo2("哈哈",123));
collection.add(new Demo2("嘻嘻嘻",1234));
collection.add(new Demo2("啦啦啦",11111));

System.out.println(collection.size());//size是显示集合的长度的

Iterator iterator = collection.iterator();
//collection.iterator(); 这句代码是 调用集合的迭代器方法，是为了获取集合中的迭代器对象
//Iterator iterator 这句代码是 ，我拿到了迭代器的对象

 while(iterator.hasNext){
 //hasNext是条件判断，则next给hasNext返回是true还是false ，用于查看下一个有没有元素

 Object obj = iterator.next();//这句话可以直接写成 Demo2 demo = (Demo2)iterator.next();
 //用于：返回iterator的boolean的类型，吧每次遍历的指针给你，每次循环，达到实现属性类使用


 //因为是new Demo2这个类的，所以我们get来取这个类的属性

  Demo2 demo = (Demo2)obj;//因为在集合中我们new的没有指针，所以必须来遍历指针指引这个属性类

 System.out.println(demo.geting());
 System.out.println(demo.getin);
 }

迭代器与集合错误特点：

在迭代器操作过程中，不能用集合来操作删除，添加，只能打印。

不能迭代器和集合同时对元素进行修改，添加，和删除。

 class Demo{
  public static void main(String[]args){
    List list = ArrayList();
       yi(list);
   } 
  public static void yi(List list){
     list.add("1");
     list.add("2");
     list.add("3");
     Iterator It = list.iterator();
     while(It.hasNext){
     Object obj = It.next();
     if(obj.equals("2")){
      list.add("55");
    //在这一步把list集合元素给了迭代器，在迭代器过程中，突然使用集合来操作元素，所以报错！
    //吧集合元素给了迭代器，要不集合操作，要不迭代器操作，否则出现异常报错！
          }
       }
     }
 }

如果坚决用集合迭代器来增加元素，那么我们就用迭代器的子类（listIterator）的方法实现

语法如下：

 class Demo(
 public static void main(String[]args){
 List list = new ArrayList();
  yi(list);
  System.out.println(list);

    }
  public static void yi(List list){
    list.add("1"); 
    list.add("2");
    list.add("3");
    ListIterator It = list.iterator();
   while(It.hasNext()){
  // System.out.println(It.next());//此时不能这样，因为next是迭代器的返回，如果有两个迭代器操作时，除了此内存操作，会报错！
   Object obj = It.next();
    if(obj.equals.("3")){  //如果里面有这个字符串，那么进来添加一个
       It.add("4");  
       } 
     }

     }
}

用for循环遍历这个集合迭代器元素:、

语法如下：

 for(Iterator ii = collecton.iterator(); ii.hasNext(); ){
  Demo2 dem  =(Demo2) ii.next();
//迭代器获取到元素的地址，查看堆内存中是否为空，返回给迭代器条件判断，然后吧每次遍历的地址值给了这个对象名
   System.out.println(dem.geting());
 }

}
class Demo2{
   private Stirng ing;
   private int in;

   public Demo2(){}

   public Demo2(String ing,int in){
   this.ing = ing;
   this.in = in;

   }
   public String geting(){
     return ing;
   }
   public void seting(String ing){
    this.ing = ing;
   }
   public int getin(int in){
    return in;
   }
   public void setin(int in){
   this.in = in;
   }

Collecton接口子类List

List接口：特有的常见方法，有一个共性特点就是都可以操作角标

Vector：内部是数组数据结构，是同步的。增删，查询很慢。

ArrayList：内部是数组数据结构，是不同步的，替代了Vector。查找元素很快，删除其中，则坐标移动，一动则动全身，因为他储存方式是数组，增删，其动全部坐标，删除也是。

LinkedList：内部是链表数据结构，是不同步的，增删元素的速度很快

以下是常见方法区

1. 添加：

void add(index,element);

void add(index,collecton);

2.删除：

Object remove(index);

3.修改：

Object set(index,element);

4.获取：

Object get(index);

int indexOf(object);

int lastIndexOf(object);

List subList(fron,to);

增加元素：void add(index,collecton):获取元素的角标，来添加元素

语法如下：

class Demo{
 public static void main(String[]args){
 List list = new ArrayList();   
     yi(list);//调用他的引用
   } 
public static void yi(List list){//获取List 的list对象名
   list.add("abc1");
   list.add("abc2");
   list.add("abc3");    

   list.add(1,"abc5");
  //这句话就是在集合1角标哪里直接插入
    }  
}

删除元素： Object remove(index)：在remove()参数括号里面填写哪个坐标，就删除哪个元素。

语法如下：

 class Demo{
publc static void mian(String[]args){
  List list = new ArrayList();
   yi(list);     
  }
public static void yi(List list){
    list.add("abc");
    list.add("aaa");
    list.add("add");

    System.out.println(list.remove(2));
  //这句话就是用List调用自身的方法，remove删除坐标2的元素。
    }
 }

修改元素：Object set(index,”asdf”);在指定坐标，修改元素

语法如下：

 class Demo{
    public static void main（String[]args){
     List list = new ArrayList();
        yi(list);
    }
     public static void yi(List list){
       list.add("a");
       list.add("b");
       list.add("c");
       System.out.println(list.set(1,"ha"))
  //吧指定坐标的元素修改成当前元素。
     } 
   }

get(int index)：这种方法用于返回列表中指定位置的元素。

语法如下：

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

     Collecetion colleciotn = new ArrayList();

     collection.add(new Demo1("哈哈",123));
     collection.add(new Demo1("我是",11));
     System.out.println(collection.size());

     for(int i = 0;i<collection.size();i++){
      List list = (List)collection;
       Demo1 demo  =(Demo1) list.get(i);
       //为什么要用List了？因为只有List是colleection的子类，但是List这个接口有get方法，用来获取元素
              }

           }
      }

      class Demo1{
      private String ing ;
      private int in;

      Demo1(){}

      Demo1(Stirng ing,int in){
      this.ing = ing;
      this.in = in;
      }
      public String geting(){
      return ing;
      }
      public void seting (String ing){
      this.ing = ing;
      }
      public int getin(){
      return in;
      }
      public void setin(int in){
      this.in = in;
      }
    }

LinkedList();类来自List接口。

addFirst()方法：　　　　　用于来逆序集合的元素

增加头部元素：

 //此段代码不能执行！只为参考不常用的方法！
class Demo{
 public static void main(String[]args){

 LinkedList linkedlinst = new LinkedLint();

  yi(linkedlist);
    } 
 public static void yi(LinkedList linkedlist){

   linkedlist.addFirst("1");
   linkedlist.addFirst("2");
   linkedlist.addFirst("3");
   linkedlist.addFirst("4");
   //删除迭代器的头一个元素，remove是删除，First是头部
  System.out.println(removeFirst);
  //这句代码是 删除头部。

  //get是获取元素，
System.out.println(getFirst());
 //获取几个第一个元素

 //因为都是collection的接口的子类，我们用LinkedList调用collection迭代器  
    Iterator It = linkedlist.iterator(); 
    while(It.hasNext()){
      System.out.println(It.next());
      }
    }
 }

Collection接口子类：

set接口：元素不可重复，是无序的。继承了collection接口，因此拥有collection方法。

set接口有两个子类比较常用。HashSet，TreeSet。

Hashset；内部数据结构是哈希表，是不同步的：此类实现set接口，它不保证set的迭代顺序，特别是他不保证该顺序恒久不变，此类允许使用null元素。所以存储元素的时候，使用的元素的hashCode方法来确定位置，如果位置相同，在通过元素的equals来确定是否相同　　　　　　储存方式就是:　　用hashcode方法确定元素的地址，然后在用equals判断元素的内容

HashSet类：

HashSet方法：

 class Demo{
public static void main(string[]args){
   HashSet hashset = new HashSet();
  hashset.add("1");
  hashset.add("2");
  hashset.add("3");
  hashset.add("4");  
  Iterator It = hashset.iterator();
  while(It.hasHext()){
    System.out.println(It.next());
     } 
  }
}
  //打印出来不保证迭代顺序，如果有重复元素，只打印一个
  //因为HashSet类是根据哈希算法的元素来存储的。用于查找速度快。不能重复元素，是因为他根据算法来储存的，所以直接覆盖了当前的相同的元素。

LinedHashSet方法：

 class Demo{
 public static void main(String[]args){
  HashSet linkedHashSet = new LinkedHashSet();
    linkedHashSet.add("1");
    linkedHashSet.add("2");
    linkedHashSet.add("3");
    linkedHashSet.add("1");
    linkedHashSet.add("2");
    Iterator It = linkedHashSet.iterator();
    while(It.hasNext()){
        System.out.println(It.next(););
          } 
    }
 }
//LinkedHashSet();方法是元素有序，只唯一。因为他是哈希列表，链接列表实现。

TreeSet：可以对Set集合中的元素进行排序，是不同步的。

基本语法如下：

 public class tersetDemo {
 public static void main(String[]args){
     TreeSet treeset  =new TreeSet();
     treeset.add(new Demo("嘻嘻",19));
     treeset.add(new Demo("哈哈",12));
     treeset.add(new Demo("啦啦",42));
     treeset.add(new Demo("呵呵",49));
     treeset.add(new Demo("突突",13));

     for(Iterator It = treeset.iterator();It.hasNext();){

      System.out.println(It.next());
          }

      }
 }

class Demo{
private String name;
private int in;
Demo(){

}
Demo(String name,int in){
    this.name = name;
    this.in = in;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public int getIn() {
    return in;
}
public void setIn(int in) {
    this.in = in;
  }

} 
//这段代码会报异常： 
  Exception in thread "main" java.lang.ClassCastException: Demo1.Demo cannot be cast to java.lang.Comparable
at java.util.TreeMap.put(TreeMap.java:542)
at java.util.TreeSet.add(TreeSet.java:238)
at Demo1.tersetDemo.main(tersetDemo.java:8)

TreeSet

1，元素不可重复

2，可以按照自然顺序排序

3，如果排序的是引用数据类型，需要实现Comparable接口

此接口需要重写compareTo()方法，此方法规定，如果该对象小于，等于或大于指定对象，则分别返回负整数，零或正整数。

正确的TreeSet方法：数字排序

class Demo{
public static void main(String[]args){
  set set =new TreeSet();
  set.add(new Demo1("张三",12));
  set.add(new Demo1("李四",11));
  set.add(new Demo1("王麻子",213));
  for(Iterator It = set.iterator();It.hasNext()){
    Demo1 demo = (Demo1)It.next();
  System.out.println(demo.getname());  
     }

 } 
class Demo1 implements Comparable{        
 //实现Comparable接口,调用接口的compareTo方法；

 private String name;
 private int in;
 Demo1(){
 }
 Demo1(String name,int in){
 this.name = name;
 this.in = in;
 }
 public String getName(){
   return name;
 }
 public void setnName(String name){
   this.name = name;
 }
 public int getIn(){
   return in;
 }
 public void setIn(int in){
   this.in = in;
 }
 //需要重写Object的toString方法; 
 public String toString(){
    return name +"；"+ in;
 }

 //调用接口的方法
 public int compareTo(Object o)
   Demo1 demo = (Demo1)o;
   if(this.in>demo.in){
      return 1;
   }if (this.in<demo.in){
      return -1;
   }else{
      return 0;
   }
  //这样就是排序他的数字属性这个。
}

如果全部返回的是1，那么按顺排序。

 public int compareTo(Object o) {
   Demo dd =(Demo)o;
   if(this.in<dd.in ){
      return 1;
   }if (this.in>dd.in){
      return 1; 
   }else{
       return 1;
   }
 //在方法里面返回的负数和正数来排序的。

}
}

字符串排序

 class treesetDemo1{
 public static void main(String[]args){
  TreeSet treeset =new TreeSet();
  treeset.add("星期一");
  treeset.add("星期二");   
  treeset.add("星期三");
  treeset.add("星期四");
  Iterator It = treeset.iterator();

    }
}
class Demo3{
 private String name;
 Demo3(){
 }
 Demo3(String name){
  this.name = name;
 }
 public String getName(){
    return name;
}
public void setName(String name){
    this.name = name;
}
public String toString (){

}


 }

Map：

一次添加一对元素，collection一次添加一个元素。

Map也称为双列结合，collection集合称为单列集合。

其实Map集合中存储的是键值对。Map集合中必须保证键的唯一性。

1，添加

value put(key,value):返回前一个和key关联的值，如果没有返回null

2，删除

value clear();清空Map集合。
value remove(key);根据指定的key翻出这个键值对。

3，判断

boolean containsKey(key):
boolean containsValue(value):
boolean isEmpty();

4，获取

value get(key);通过建获取值，如果没有该键返回null。当然可以通过返回null，来判断是否包含指定建。
int size();获取键值对的个数。

put方法；

class Demo1{
 public static void main(String[]args){
 Map map = new HashMap();
     map.put("键","值");
     map.put("键", "值1");
     map.put("活动钱包","不好" );
     map.put("活动钱包","不好");
     map.put("呵呵", "哈哈");
//如果键相同，那么第一个不打印，键和值相同，不重复。 是无序的 
    }
}

Map集合和Collection集合不一样，所以Map集合里面没有迭代器方法。

取出Map中的所有元素。　　　原理，通过keySet方法获取map中所有的键所在的set集合，再通过set的迭代器获取到每一个键，在对每一个键获取对应的的值即可。

 class HashMap{
  public static void main(String[]args){
  HashMap hash = new HashMap();
  hash.put("1","一");
  hash.put("2","二");
  hash.put("3","三");
  //获取到键遍历：
  Set set = map.keySet();
 //因为HashMap的接口是Set；
 //通过键拿到值遍历
 for(Iterator It = set.iterator();It.hasNext();){
      Object obj = It.next();
   //吧键给这个obj
  System.out.println(obj+""+map.get(obj));
   //obj的值   为什么需要get了？ get是获取到当前的值
  }


 }       

 }

存键打值 Map对象名.get(键)；

 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Set;
 public class HashMapDemo3 {
 public static void main(String[]args){
   HashMap<String,Student> map = new HashMap<String ,Student>();
   Student set = new Student("李明","男");
   map.put("Jack",set);
    boolean  b  = map.containsKey("Jack");   //判断这个map集合是否存在这个键。
    Set<String> s = map.keySet(); //map没有迭代器方法，set有，吧字符串的键，转成set集合里面，
    if(b){
   for( Iterator<String> it = s.iterator();it.hasNext();){
    String ing =  it.next();
    Student stu = map.get(ing);
    System.out.println("Jack对应的学院姓名是："+stu.getName()+"：性别是"+stu.getSex());
                 }
           }

     }
 }

class Student{
private String name;
private String sex;
Student(){}
Student(String name,String sex){
     this.name = name;
     this.sex = sex;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public String getSex() {
    return sex;
}
public void setSex(String sex) {
    this.sex = sex;
}

}

Collections类常用方法：

Collections和Collection不同，前者是集合的操作类，后者是集合接口!

Collections提供的常用静态方法：

sort(): 排序

 import java.util.ArrayList;
   import java.util.Collections;
   import java.util.Iterator;
   public class CollectionMinDemo {
   public static void main(String[]args){
   ArrayList list = new ArrayList();
   list.add(new Student1("指尖",12));
   list.add(new Student1("跳动",23));
   list.add(new Student1("安全",12));
   list.add(new Student1("异常",314));
   list.add(new Student1("阿斯顿",123));
   Collections.sort(list); 
   //在这里就是 系统就要给这些的值进行排序，然后我们在遍历即可！

   for(Iterator It =  list.iterator();It.hasNext();){
       Object obj = It.next();
       Student1 stu = (Student1)obj;
       System.out.println("姓名："+stu.getName()+":"+stu.getAge());
  //           System.out.println(list);
   }

  //       System.out.println(list);

  }
}
class Student1 implements Comparable<Student1>{
private String name;
private int age;
Student1(){}
Student1(String name,int age){
    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 int compareTo(Student1 o) {
  int num = this.age - o.age;
    return num;
//比较他们两个差值，然后返回给这个属性类，然后系统进行排序。
}

}

小练习2：

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

  public class CollectionsDemo3 {
  public static void main(String[]args){
   ArrayList<Student> arr = new ArrayList<Student>();
   arr.add(new Student("北京大学","北京",100,7));
   arr.add(new Student("复旦大学","上海",82,7));
   arr.add(new Student("北京大学","北京",98,7));
   arr.add(new Student("浙江大学","浙江",82,5));
   arr.add(new Student("武汉大学","湖北",82,6));
   arr.add(new Student("中山大学","广东",76,4));
   arr.add(new Student("国防科技大学","湖南",80,4));
   arr.add(new Student("南京大学","江苏",80,5));
   arr.add(new Student("上海交通大学","上海",81,4));
   arr.add(new Student("中国人民大学","上海",42,1));
   Collections.sort(arr);
//      System.out.println("");
   for(Iterator<Student> It = arr.iterator();It.hasNext();){
          Student stu = It.next();
     System.out.println(stu.getName()+"\t"+stu.getDiqu()+"\t"+stu.getAge()+"\t"+stu.getIn());
   }

  }
  }

class Student implements Comparable<Student>{
private String name;
private String Diqu;
private int age;
private int in;
Student(){}
Student(String name,String Diqu,int age ,int in){
    this.name = name;
    this.Diqu = Diqu;
    this.age = age;
    this.in = in;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public String getDiqu() {
    return Diqu;
}
public void setDiqu(String diqu) {
    Diqu = diqu;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}
public int getIn() {
    return in;
}
public void setIn(int in) {
    this.in = in;
}
@Override
public int compareTo(Student o) {
 int num = this.age - o.age;
 int num2 = num == 0?this.in-o.in:num;
    return num2;
 /*比较总分，的同时，如果发现等于0 ，那么总分必定一样，在这种的情况下。
     就比较他的星级，返回他的差！如果不能与0 就返回num！他的总分!!!!

 */
 }

   }

指尖跳动

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础（集合）

集合集合大概理论：List接口 ArrayList：实现了可变的数组，在内存中分配连续的空间，便利元素和随机访问元素的效率比较高。 LinkedList：采用链表储存方式，插入，删除元素时效率比较高！ set接口 HashSet:唯一，重复，直接不能储存进去！无序的，是采用哈希吗储存的！ Collection 是层次结构根接口List:
复制链接

扫一扫