java习题-集合框架-泛型

集合框架

一 去除List集合中的重复元素。

思路：　　

1，先创建一个临时容器。用于存储唯一性的元素。
2，遍历原容器，将遍历到的元素到临时容器中去判断，是否存在。
3，如果存在，不存储到临时容器，如果不存在，存储到临时容器中。
4，遍历结束后，临时容器中存储的就是唯一性的元素。
5，如果需要将这些唯一性的元素保留到原容器中，只要将原容器清空，将临时容器中的元素添加到原容器中即可。
代码实现

package cn.itcast.api.b.list.subclass;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import cn.itcast.domain.Student;

public class ArrayListTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        List list = new ArrayList();
//        list.add("abc1");
//        list.add("abc2");
//        list.add("abc1");
//        list.add("abc2");
//        list.add("abc1");
//        list.add("abc2");
        
        list.add(new Student("lisi1",21));
        list.add(new Student("lisi2",22));
        list.add(new Student("lisi1",21));
        list.add(new Student("lisi2",22));
        list.add(new Student("lisi1",21));
        
        getSingleElement(list);//去除重复元素。
        
        System.out.println(list);

    }
    
    /*
     * 案例：去除List集合中的重复元素。
     * 
     * 思路：
     * 1，先创建一个临时容器。用于存储唯一性的元素。
     * 2，遍历原容器，将遍历到的元素到临时容器中去判断，是否存在。
     * 3，如果存在，不存储到临时容器，如果不存在，存储到临时容器中。
     * 4，遍历结束后，临时容器中存储的就是唯一性的元素。
     * 5，如果需要将这些唯一性的元素保留到原容器中，只要将原容器清空，将临时容器中的元素添加到原容器中即可。
     * 
     */
    public static void getSingleElement(List list){
        
        //1,创建一个临时容器。
        List temp = new ArrayList();
        
        //2,遍历原容器。
        for (Iterator it = list.iterator(); it.hasNext();) {
            Object obj = it.next();
            
            //对遍历到的每一个元素都到临时容器中去判断是否包含。
            if(!temp.contains(obj)){//如果不存在，
                temp.add(obj);//添加到临时容器。
            }
        }
        //唯一性的元素已经被记录到临时容器中。
        //清空原容器中的元素。
        list.clear();
        
        //把临时容器中的元素添加到原容器中。
        list.addAll(temp);
        
    }

}

 二 队列的LinkedList的实现

思路：队列的思想是先进先出

代码实现

package test;

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

/*1，去除List的重复元素。
2，堆栈，队列的LinkedList的实现，★★★★★
3，字符串按照长度排序。
4，对学生按照姓名排序。*/

class test {
    public static void main(String[] args) {
        // 创建一个队列对象
        Queue queue = new Queue();
        queue.enQueue("a");
        queue.enQueue("b");
        System.out.println(queue.deQueeu());
        
        
        
    }
}
class Queue{
    private LinkedList<String> list ;
    Queue(){
        list = new LinkedList<String>();
    }
    // 进队操作
    public void enQueue(String s){
        list.addLast(s);
    }
    // 出队操作
    public String deQueeu(){
        return list.removeFirst();
    }
}

 三 字符串按照长度排序

思路：
* 1，字符串之所以可以排序，因为是已经实现Comparable接口重写compareTo方法。
* 建立了字符串的自然排序。
* 2，但是自然排序不是需求中所需要的。咋办？
* 只能使用比较器。需要自定义一个比较器。

 代码体现

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

        Set set = new TreeSet(new ComparatorByLength());
        set.add("abc");
        set.add("haha");
        set.add("aa");
        set.add("hiaia");
        System.out.println(set);

    }
}


package test;

import java.util.Comparator;

public class ComparatorByLength implements Comparator {

    public int compare(Object o1, Object o2) {
        String s1 = (String)o1;
        String s2 = (String)o2;
        
        int temp = s1.length() - s2.length();
        
        return temp==0?s1.compareTo(s2):temp;
    }

}

四 对学生按照姓名排序 

代码体现

public static void main(String[] args) {
        Set set = new TreeSet();
        set.add(new Student("hisi6",22));
        set.add(new Student("bisi8",22));
        set.add(new Student("zisi5",25));
        set.add(new Student("cisi3",23));
        set.add(new Student("lisi7",20));
        System.out.println(set);

    

    }

    public int compareTo(Object o) {
        Student stu = (Student)o;
        return this.name.compareTo(stu.name);
    
    }

 五 HashSet中存储自定义的元素，要求刻意存储重复元素

思路:让equals 返回false就可以了

代码体现

public boolean equals(Object obj) {
        return false;
    }
    public static void main(String[] args) {
        HashSet set =new HashSet();
        set.add(new Student("a",1));
        set.add(new Student("a",1));
        System.out.println(set.size());
    }

六 TreeSet中存储了字符串

要求按照字典顺序，从大到小排序

思路:实现Comparator里面的compare ,并且返回相反数

代码体现:

    public int compare(Object o1, Object o2) {
        String s1 = (String)o1;
        String s2 = (String)o2;
        
        
        return (-s1.compareTo(s2));
    }


public static void main(String[] args) {
        TreeSet set = new TreeSet(new ComparatorByZA());
        set.add("a");
        set.add("b");
        System.out.println(set);
        
    }

 泛型

一 Collection和Collections的区别？

Collection是集合框架的顶层接口。
下面有两个开发中常用的List 和 Set集合。
根据数据结构的不同，也有了很多的具体子类集合对象。

Collections：是集合框架中的用于操作集合的工具类。
提供了很多的静态方法：比如：对list排序，二分查找，比如可以获取最值等。
其中一组可以非同步集合转成同步 集合的方法

二 对List集合中存储的重复字符串元素，按照长度进行排序

 思路:利用collections里面的sort方法

代码体现:

package cn.itcast.test;

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

public class Test2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //作业2：List集合中存储的重复字符串元素，按照长度进行排序。
        
        List<String> list = new ArrayList<String>();
        list.add("nba");
        list.add("abcde");
        list.add("nba");
        list.add("cctv");
        list.add("zz");
        list.add("cctv");
        list.add("itcast");
        
        Collections.sort(list,new Comparator<String>() {

            @Override
            public int compare(String o1, String o2) {
                int temp = o1.length() - o2.length();
                return temp==0?o1.compareTo(o2):temp;
            }
            
        });
        
        for(String str : list){
            System.out.println(str);
        }

    }

}

 三 在一个已排序的List集合中插入一个字符串

继续保证这个集合原有排序，问如何获取这个位置

思路:用collections里面的方法来做,

1 先排序

2 在找插入位置.这个位置是 (-(插入点) - 1)

代码体现

List<String> list = new ArrayList<String>();
        list.add("nba");
        list.add("abcde");
        list.add("nba");
        list.add("cctv");
        list.add("zz");
        list.add("cctv");
        list.add("itcast");
        Collections.sort(list);
        System.out.println(list);
        String key = "ac";
        // 找一个元素在集合中出现的位置。
        int index = Collections.binarySearch(list, key);
        if(index<0){
            index = -(index+1);
        }
        System.out.println("index=" + index);

四 定义一个通用的(带泛型)获取集合最大值的方法

这个是重点@@@@

package cn.itcast.api.a.generic;

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

import cn.itcast.domain.Student;

public class GenericTest2 {

    /**
     * @param args
     */
    public static void main(String[] args) {

        /*
         * 案例：获取集合中元素的最大值。
         * 
         * 思路： 1，定义变量记录每次比较后较大的值，初始化元素中任意一个。 2，遍历容器
         * 3，在遍历中和变量中记录的元素进行比较。并将较大的值记录到变量中。 4，遍历结束，变量中记录的就是最大值。
         */

        Collection<Student> c1 = new ArrayList<Student>();
        c1.add(new Student("xiaoming1", 30));
        c1.add(new Student("xiaoming2", 36));
        c1.add(new Student("xiaoming3", 22));
//        c1.add(new Dog());

        Student stu = getMax(c1);
        System.out.println(stu);
        
        Collection<String> c2 = new ArrayList<String>();
        c2.add("abcd");
        c2.add("java");
        c2.add("z");
        c2.add("nba");
        String s = getMax(c2);
        System.out.println("s="+s);
        
        Collection<Dog> c3 = new ArrayList<Dog>();
//        getMax(c3);//已经做了限定，说明传递的集合中的元素类型必须是Comparable的子类。否则编译失败。
    }

public static <T extends Comparable<? super T>> T getMax(Collection<? extends T> c,Comparator<? super T> comp){
        
        if(comp==null){
            return getMax(c);
        }
    
        Iterator<? extends T> it = c.iterator();
        
        T max = it.next();
        
        while(it.hasNext()){
            
            T temp = it.next();
            
            if(comp.compare(temp, max)>0){
                max = temp;
            }
        }
        
        return max;
    }

    // 升级版。要操作的元素的类型确定不？不确定。使用泛型限定。getMax方法接收的集合中的元素无论时什么类型，必须具备自然排序，必须是Comparable的子类。
    public static <T extends Comparable<? super T>> T getMax(Collection<? extends T> c){
        
        Iterator<? extends T> it = c.iterator();
        
        T max = it.next();
        
        while(it.hasNext()){
            
            T temp = it.next();
            
            if(temp.compareTo(max)>0){
                max = temp;
            }
        }
        
        return max;
    }
    
    /*
    //不加泛型时，无法明确集合中的元素时什么类型，为了便于操作用Object
    public static Object getMax(Collection c1) {

        // 1,定义变量，记录集合中任意一个元素，Collection集合取出元素的方式只有迭代器。
        Iterator it = c1.iterator();
        Object max = it.next();

        // 2,遍历容器。
        while (it.hasNext()) {
            Object o = it.next();
            Comparable temp = (Comparable)o;
            
            if (temp.compareTo(max) > 0) {
                max = temp;
            }
        }
        return max;
    }
*/
    /*
     * //这个功能虽然实现，但是有局限性，因为这个功能只能对存储了Student对象的集合进行最大值的获取。 public static Student
     * getMax(Collection<Student> c1) {
     * 
     * //1,定义变量，记录集合中任意一个元素，Collection集合取出元素的方式只有迭代器。 Iterator<Student> it =
     * c1.iterator(); Student max = it.next();
     * 
     * //2,遍历容器。 while(it.hasNext()){ Student temp = it.next();
     * 
     * if(temp.compareTo(max) > 0){ max = temp; } } return max; }
     */

}
class Dog{}

 五 

5，一个ArrayList对象alist中存有若干个字符串元素，现欲遍历该ArrayList对象，
删除其中所有值为"abc"的字符串元素，请问下面的实现正确么？如有问题，
会出现什么问题？如何更正？

int size = alist.size();
for(int i = 0; i < size; i++) {
if("abc".equals(alist.get(i))) {
alist.remove(i);
}
}

package cn.itcast.test;

import java.util.ArrayList;
import java.util.List;

public class Test5 {

    /**
     * @param args
     */
    public static void main(String[] args) {
//        5，一个ArrayList对象alist中存有若干个字符串元素，现欲遍历该ArrayList对象，
//        删除其中所有值为"abc"的字符串元素，请问下面的实现正确么？如有问题，
//        会出现什么问题？如何更正？
        
        //1,移除成功会导致集合长度改变， 必须要重新获取size。导致了IndexOutOfBoundsException。
        //解决方案：在for循环的条件上，调用size方法。
        //2,出现了有些abc没有被删除。那么是因为删除后，角标自增，原角标上的后替换过来的元素没有被判断。
        //解决方案：在删除后，要让角标自减，重新判断替换过来的元素。
        
        List<String> list = new ArrayList<String>();
        list.add("nba");
        list.add("abc");
        list.add("abc");
        list.add("abc");
        list.add("abc");
        list.add("cctv");

        System.out.println(list);
//        int size = list.size();
        for(int i = 0; i < list.size(); i++) {
          if("abc".equals(list.get(i))) {
            list.remove(i);//会改变集合的长度。应该重新获取size。
            i--;
          }
        }

        System.out.println(list);
    }

}