java 集合框架题_java习题-集合框架-泛型

最新推荐文章于 2023-02-13 17:53:43 发布

跨考考研

最新推荐文章于 2023-02-13 17:53:43 发布

阅读量328

点赞数

文章标签： java 集合框架题

本文链接：https://blog.csdn.net/weixin_35867508/article/details/114175756

版权

集合框架

一去除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 classArrayListTest {/**

* @param args*/

public static voidmain(String[] args) {

List list= newArrayList();//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 voidgetSingleElement(List list){//1,创建一个临时容器。

List temp = newArrayList();//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，对学生按照姓名排序。*/

classtest {public static voidmain(String[] args) {//创建一个队列对象

Queue queue = newQueue();

queue.enQueue("a");

queue.enQueue("b");

System.out.println(queue.deQueeu());

}

}classQueue{private LinkedListlist ;

Queue(){

list= new LinkedList();

}//进队操作

public voidenQueue(String s){

list.addLast(s);

}//出队操作

publicString deQueeu(){returnlist.removeFirst();

}

三字符串按照长度排序

思路：

* 1，字符串之所以可以排序，因为是已经实现Comparable接口重写compareTo方法。

* 建立了字符串的自然排序。

* 2，但是自然排序不是需求中所需要的。咋办？

* 只能使用比较器。需要自定义一个比较器。

代码体现

classtest {public static voidmain(String[] args) {

Setset = new TreeSet(newComparatorByLength());set.add("abc");set.add("haha");set.add("aa");set.add("hiaia");

System.out.println(set);

}

package test;

import java.util.Comparator;public classComparatorByLength implements Comparator {public intcompare(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 voidmain(String[] args) {

Setset = newTreeSet();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 intcompareTo(Object o) {

Student stu=(Student)o;return this.name.compareTo(stu.name);

}

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

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

代码体现

publicboolean equals(Object obj) {return false;

}public static voidmain(String[] args) {

HashSetset =newHashSet();set.add(new Student("a",1));set.add(new Student("a",1));

System.out.println(set.size());

}

六 TreeSet中存储了字符串

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

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

代码体现:

public intcompare(Object o1, Object o2) {

String s1=(String)o1;

String s2=(String)o2;return (-s1.compareTo(s2));

}public static voidmain(String[] args) {

TreeSetset = new TreeSet(newComparatorByZA());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 classTest2 {/**

* @param args*/

public static voidmain(String[] args) {//作业2：List集合中存储的重复字符串元素，按照长度进行排序。

List list = new ArrayList();

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() {

@Overridepublic intcompare(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 list = new ArrayList();

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 classGenericTest2 {/**

* @param args*/

public static voidmain(String[] args) {/** 案例：获取集合中元素的最大值。

* 思路： 1，定义变量记录每次比较后较大的值，初始化元素中任意一个。 2，遍历容器

* 3，在遍历中和变量中记录的元素进行比较。并将较大的值记录到变量中。 4，遍历结束，变量中记录的就是最大值。*/Collection c1 = new ArrayList();

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 c2 = new ArrayList();

c2.add("abcd");

c2.add("java");

c2.add("z");

c2.add("nba");

String s=getMax(c2);

System.out.println("s="+s);

Collection c3 = new ArrayList();//getMax(c3);//已经做了限定，说明传递的集合中的元素类型必须是Comparable的子类。否则编译失败。

}public static > T getMax(Collection extends T> c,Comparator super T>comp){if(comp==null){returngetMax(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;

}

}returnmax;

}//升级版。要操作的元素的类型确定不？不确定。使用泛型限定。getMax方法接收的集合中的元素无论时什么类型，必须具备自然排序，必须是Comparable的子类。

public static > 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;

}

}returnmax;

}/*//不加泛型时，无法明确集合中的元素时什么类型，为了便于操作用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 c1) {

* //1,定义变量，记录集合中任意一个元素，Collection集合取出元素的方式只有迭代器。 Iterator 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 classTest5 {/**

* @param args*/

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

List list = new ArrayList();

list.add("nba");

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);

}