尚学堂百战程序员1573题------第八章容器

最新推荐文章于 2024-10-07 15:56:52 发布

影shy

最新推荐文章于 2024-10-07 15:56:52 发布

阅读量676

点赞数 1

分类专栏： javase 文章标签： java

本文链接：https://blog.csdn.net/weixin_49326936/article/details/119788553

版权

javase 专栏收录该内容

11 篇文章 3 订阅

订阅专栏

1、容器指的是“可以容纳其他对象的对象”，这种说法对吗?

对的

2、Collection/Set/List的联系跟区别?

（1）collection是Java集合顶级接口，存储一组不唯一，无序的对象；

（2）list接口和set接口是collections接口的两个子接口；

（3）list接口存储一组不唯一，有序（插入顺序）的对象；

Set接口存储一组唯一，无序的对象；

3、Set和List的特点跟区别?

(1)list:

1）是有序的collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引来访问list中的元素，这类似于Java的数组。

2）凡是可以操作索引的方法都是list接口特有方法。

（2）set：

1）接口存储一组唯一、无序的对象（存入和取出的顺序不一定一致）。

2）操作数据的方法与list类似，set接口不存在索引相关的方法。

4、【上机】练习Collection接口中常用的方法

        add(Object obj):添加，存储的是对象的引用；
        size():容器中元素的实际个数；
        remove(Object obj):删除一个元素；
        removeAll(Collection c):删除与集合c中的元素相同的元素；
        retainAll(Collection c): 只保留当前集合（调用此方法的集合）与集合c（此方法的参数）

        中相同的元素；
        contains(Object obj):判断集合中是否存在元素obj；
        isEmpty():判断集合是否为空；
        Iterator():生成此集合的迭代器；

5、【上机】下面的代码，效果一致吗? 分析说明之。


Collection c = new HashSet();

              Collection c2 = new HashSet();

              Apple a = new Apple();

              c.add(a);

              c2.addAll(c); 

//增加另一个容器中所有的元素！      

              Collection c = new HashSet();

              Collection c2 = new HashSet();

              Apple a = new Apple();

              c.add(a);

              c2.add(c);

c2.addAll(c)是把【集合c中的元素】添加到集合c2里；

c2.add(c)是把【集合c】当作一个元素添加到集合c2里；

6、想取两个容器中元素的交集，使用哪个方法?

retainAll(Collection c): 只保留当前集合（调用此方法的集合）与集合c（此方法的参数）中相同的元素。

7、说明isEmpty的作用，并说明下面代码有问题吗?

Collection c = null;
System.out.println(c.isEmpty());

isEmpty():判断集合是否为空，也就是集合中实际元素个数是否为0，由此得知调用此方法时集合是存在的（如果集合都不存在，也就谈不上为空与否了）。要区分集合为空和集合不存在的含义是不同的。

下列代码Collection c = null，c没有指向任何集合，即集合并不真实存在，调用isEmpty()方法会出现空指针异常。

8、我想定义一个数组。该数组既可以放：Dog对象、也可以放Cat对象、还可以放
Integer对象，怎么定义?

实例：

Object[] objArr = new Object[]{56,123,"hello world",new Dog(),new Cat()};


class Dog{

}
class Cat{

}

9、List接口中增加了一些与顺序相关的操作方法，下面两个方法的作用是什么?

add(int index, E element) , get(int index)；

add(int index, E element) ：把元素element添加到索引为index的位置；
get(int index)：得到索引为index的元素。

10、ArrayList底层使用什么来实现的?

LinkedList是用什么实现的?

11、说出ArrayLIst、LinkedList、Vector的区别。

ArrayLIst、LinkedList两者都实现了List接口，都具有List中元素有序、不唯一的特点。
ArrayList实现了长度可变的数组，在内存中分配连续空间。遍历元素和随机访问元素的效率比较高；

LinkedList采用链表存储方式。插入、删除元素时效率比较高

Vector和ArrayList的区别联系:见294题。

12、我有一些数据，需要频繁的查询，插入和删除操作非常少，并且没有线程之间的共享，使用List下面的哪个实现类好一些?

ArrayList。

ArrayList实现了长度可变的数组，在内存中分配连续空间。遍历元素和随机访问元素的效率比较高。

13、【上机】针对List中新增的有关顺序的方法，每个都进行测试。并且使用debug来帮助我们理

解程序运行。

add(int index, Object obj):在指定索引位置(index)添加元素obj;
addAll(int index,Collections c):在指定索引位置(index)添加集合c中所有元素；
remove(int index):删除索引位置为index的元素；
set(int index, Object obj):使用元素obj替代指定索引位置上的元素；
get(int index):获取指定索引位置上的元素；
subList(int beginIndex,int endIndex):得到个List对象包含指定索引区间里元素。

14、定义Computer类，使用价格排序。(使用Comparable接口) 定义computer类

（1）定义Computer类，实现Comparable接口：
publicclass Computer implementsComparable {
privatedouble price;//私有属性；
//构造方法；
public Computer(double price) {
super();
this.price = price;
}

//实现Comparable接口中的compareTo方法；
@Override
publicint compareTo(Object o) {
Computer c=(Computer)o;

if(this.price>c.price){
return 1;
}elseif(this.price<c.price){
return -1;
}else{
return 0;
}
}

//重写toString()方法；
@Override
public String toString() {
return"Computer [price=" + price + "]";
}

}

（2）加入TreeSet;
import java.util.Iterator;
import java.util.TreeSet;

publicclass Test {
publicstaticvoid main(String[] args) {
//创建TreeSet;
TreeSet<Computer> treeSet=new TreeSet<Computer>();

//创建Computer对象；
Computer computer1=new Computer(3000);
Computer computer2=new Computer(2650);
Computer computer3=new Computer(5878.8);
Computer computer4=new Computer(6000.78);

//将Computer对象加入到treeSet中；
treeSet.add(computer1);
treeSet.add(computer2);
treeSet.add(computer3);
treeSet.add(computer4);
//为treeSet创建迭代器；
Iterator<Computer> it=treeSet.iterator();
//遍历treeSet
while(it.hasNext()){
System.out.println(it.next());
}

}

结果：实现价格排序；
Computer [price=2650.0]
Computer [price=3000.0]
Computer [price=5878.8]
Computer [price=6000.78]

15、equals返回true,hashcode一定相等吗?

是的

16、HashSet和TreeSet的区别

HashSet:
（1）存储结构：采用Hashtable哈希表存储结构
（2）优缺点：
优点：添加速度快，查询速度快，删除速度快
缺点：无序

TreeSet
（1）存储结构：采用二叉树的存储结构
（2）优缺点：
优点：有序（排序后的升序）查询速度比List快
（按照内容查询）
缺点：查询速度没有HashSet快

17、使用HashSet存储自定义对象，为什么需要重写hashCode()和equals()？

        HashSet存储用的哈希表结构，哈希表需要用到hashCode()和equals()方法：
        hashCode()产生hash值以计算内存位置；
        当hash值相同时要调用equals()方法进行比较。
        如果不重写，调用的是Object的hashcode，而Object的hashCode实际上是地址。系统类已经覆盖了hashCode方法。
        所以HashSet存储自定义对象的化要重写hashCode()和equals()方法，目的是告诉程序去除重复元素的策略。

18、使用TreeSet存储多个学生数据，实现按照不同属性值进行排序？

（1）创建一个Student类, 实现Comparable接口；
publicclass Student implementsComparable {
//私有属性；
privateint id;
privateint score;
//getter和setter方法；
publicint getScore() {
return score;
}

publicvoid setScore(int score) {
this.score = score;
}

publicint getId() {
return id;
}

publicvoid setId(int id) {
this.id = id;
}
//构造方法；
public Student(){

}

public Student(int id, int score) {
super();
this.id = id;
this.score = score;
}

@Override
public String toString() {
return"Person [id=" + id + ", score=" + score + "]";
}
//实现compareTo方法，这里是用id比较；
publicint compareTo(Object obj){
Student other=(Student)obj;
int result=this.id-other.id;
return result;
}

}

（2）加入TreeSet;
publicclass Test2 {
publicstaticvoid main(String[] args) {
/*
参看下面创建TreeSet时有两种方法：
代码1：使用无参构造方法TreeSet()，当 Student对象添加进去后，排序时的比较策略用的是Student内部实现的
compareTo方法（内部比较器，此例中按照学生id排序）。
代码2：使用有参构造方法new TreeSet(scoreComp)；那么参数scoreComp是什么呢？它表示的是一个外部比较器的对
象。在什么情形下使用呢？当用TreeSet实现排序时，我们不想用Student的内部比较器（也就是说不想用id排序），
想用学生score排序？那怎么办呢？有同学说，把内部比较器改一下呗，改成用score排序的。但改来改去是不是不够
灵活呢？我们有另外一种方法。还记得外部比较器吗？Student的内部比较器我们可以不改，再为Student类定义一个
外部比较器（见以下代码中“定义外部比较器”的部分），定义外部比较器要实现Comparator接口中的compare
(Object obj1,Object obj2)（如果忘记了就往前翻翻吧），在这个方法中实现用分数(score)比较。
以此类推，如果你想用其它属性比较（如年龄，姓名等），可以继续定义相应的外部比较器，使
用方法参见代码2.
*/

/*
代码1：
Set treeSet=new TreeSet();
*/

/*
代码2：
ScoreComp scoreComp=new ScoreComp();//定义一个外部比较器的对象；
Set treeSet=new TreeSet(scoreComp);//把外部比较器对象作为TreeSet构造方法的参数；
*/
Student p1=new Student(1,78);
Student p2=new Student(2,67);
Student p3=new Student(3,96);
Student p4=new Student(4,87);

treeSet.add(p3);
treeSet.add(p4);
treeSet.add(p1);
treeSet.add(p2);

Iterator it=treeSet.iterator();

while(it.hasNext()){
System.out.println(it.next());
}

}

}

//定义外部比较器；
class ScoreComp implementsComparator{

publicint compare(Object obj1,Object obj2){

Student p1=(Student)obj1;
Student p2=(Student)obj2;
int result=p1.getScore()-p2.getScore();//用学生分数排序；
return result;

}

}

19、【上机】说明Comparable接口作用。并定义一个学生类，使用分数来比较大小。

自定义类如Student，Product，Person等虽然不是同一类事物，但是都有比较的权利，都可以实现比较的功能。既然
是同一功能（比较），就定义一个接口吧，把方法定义在接口里，由各个类去具体实现。
实现Comparable接口的类需要实现compareTo方法，根据该方法可以根据具体的排序规则对容器中的对象进行排序。
publicclass Student implementsComparable{
privateintid;
private String sex;
private String name;
privateint score;
privateintage;

public Student() {
}
public Student(int id, String sex, String name, int score, int age) {
this.id = id;
this.sex = sex;
this.name = name;
this.score = score;
this.age = age;
}
publicint compareTo(Object o) {
Student s = (Student)o;
returnthis.score-s.score;
}
}

20、Map中，key能否重复?如果重复，会有什么现象?

key:无序，唯一；
添加重复的key不报错，会把之前重复的key覆盖了。

21、Set和Map的集合类名称相似，有没有内在的联系？

HashMap和HashSet这些集合类采用的是哈希表结构，需要用到hashCode哈希码和equals方法

22、【上机】综合使用List、Map容器存放如下数据, 并从map中取出“李四”。

姓名：张三年龄：18 体重：90 地址：北京
姓名：李四年龄：28 体重：50 地址：上海
注：不能使用Javabean封装！

(1)先创建Person类；
publicclass Person {
//私有属性；
private String name;
privateint age;
privatedouble weight;
private String address;

//getter和setter方法（略）；
//构造方法；
public Person(String name, int age, double weight, String address) {
super();
this.name = name;
this.age = age;
this.weight = weight;
this.address = address;
}

@Override
public String toString() {
return"Person [name=" + name + ", age=" + age + ", weight=" + weight + ", address=" +
address + "]";
}
}
（2）用List存放数据：
List<Person> personList=new ArrayList<Person>();

Person p1=new Person("张三",18,90,"北京");
Person p2=new Person("李四",28,60,"上海");

//把Person对象添加到personList里；
personList.add(p1);
personList.add(p2);

（3）用Map存放数据：
Map<String,Person> map=new HashMap<String,Person>();
//把Person对象添加到map里，用name作为key，Person对象作为value;
map.put(p1.getName(), p1);
map.put(p2.getName(), p2);
//提取名为“李四”的人的信息，用map.get(key)方法，返回的是此key对应的value值；
System.out.println(map.get("李四"));

23、【上机】使用JavaBean封装，完成上个题目的练习

24、【上机】写出List、Set、Map中使用泛型的例子。

        ArrayList<String> aList=new ArrayList<String>();//只能接收String类型的对象；
        Set<Integer> set=new HashSet<Integer>();//只能接收Integer类型的对象；
        Map<Integer,String> map=new Map<Integer,String>();//只能接收key类型为Integer，value类型为String。

25、使用泛型有什么好处?

泛型是JavaSE1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

Java语言引入泛型的好处是安全简单。

26、【上机】用代码写出遍历List的四种方式

finalintSIZE = list.size();
for (int i = 0; i <SIZE; i++) {
String s = list.get(i);
System.out.print(s+"");
}
System.out.println();
for (String string : list) {
System.out.print(string+"");
}
System.out.println();
Iterator<String> it = list.iterator();
while(it.hasNext()){
String s = it.next();
System.out.print(s+"");
}
}

27、【上机】用代码写出遍历Set的两种方式

1）增强for循环遍历
for (Integer integer : set) {
System.out.print(integer.intValue() + "");
}
2）Iterator 遍历
Iterator<Integer> iterator = set.iterator();
while(iterator.hasNext()){
System.out.print(iterator.next().intValue() + "");
}

28、【上机】用代码写出遍历map的方式

1：得到所有的key
Set<String> set = map.keySet();
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()){
String key = iterator.next();
System.out.println(key + "--->"+map.get(key));
}
2：得到所有的value
Collection<String> collection = map.values();
for (String string : collection) {
System.out.println("value--->"+string);
}
3：得到所有的key和value
Set<Entry<String, String>> entries = map.entrySet();
Iterator<Entry<String, String>>iterator2 = entries.iterator();
while (iterator2.hasNext()) {
Entry<String, String> entry = iterator2.next();
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key + "--->"+value);
}

29、采用增强for循环遍历List或者Set，如果List或者Set没有加泛型，能遍历吗?

能。

30、如果我想在遍历时删除元素，采用哪种遍历方式最好?

Iterator接口，接口有remove方法

31、Iterator是一个接口还是类?

Iterator接口。

32、Collection和Collections有什么区别?

Collection是Java提供的集合接口，存储一组不唯一，无序的对象。它有两个子接口List和Set。
Java中还有一个Collections类，专门用来操作集合类，它提供一系列静态方法实现对各种集合的搜索、排序、线程、安全化等操作。

33、资源文件有什么作用?

资源文件是用来配置信息的，如数据库信息，键值对信息等。

程序里需要有个方法来读取资源文件中的配置信息。

如果没有资源文件，配置信息就得写在代码里；需要修改信息时就不得不修改代码。

有了资源文件之后，一旦信息需要改变，修改资源文件就可以，不用修改代码，

更好的保证了代码的封装性。

34、【上机】在src下建立一个资源文件(不包含中文)，尝试使用Property类读取里
面的属性。

        (1)创建资源文件,我的是fruit.properties; “fruit”可以自定义，后缀名是“properties”。我写的文件内容如下
      （水果名对应的水果信息：名称，产地，价钱）：
        apple=name:apple,place:ShanDong,price:7.00RMB/500g
        orange=name:orange,place:GuangDong,price:3.99RMB/500g
        banana=name:banana,place:HaiNan,price:2.99RMB/500g
        carrot=name:carrot,place:Beijing,price:2.98RMB/500g

   Properties pro = new Properties();
        String path = StreamTest.class.getClassLoader().getResource("fruit.properties").getPath(); //当前类的类名
        System.out.println(path);
        FileInputStream in =new FileInputStream(path);

        pro.load(in);

        String info  = pro.getProperty("carrot");
        System.out.println(info);

35、【上机】使用entrySet方法遍历Map。

        Set<Entry<String, String>> entries = map.entrySet();
        Iterator<Entry<String, String>>iterator2 = entries.iterator();
        while (iterator2.hasNext()) {
        Entry<String, String> entry = iterator2.next();
        String key = entry.getKey();
        String value = entry.getValue();
        System.out.println(key + "--->"+value);
        }

36、Vector和ArrayList的区别联系

        Vector和ArrayList的区别和联系
        实现原理相同，功能相同，都是长度可变的数组结构，很多情况下可以互用
        两者的主要区别如下
        1)Vector是早期JDK接口，ArrayList是替代Vector的新接口
        2)Vector线程安全，ArrayList重速度轻安全，线程非安全
        3)长度需增长时，Vector默认增长一倍，ArrayList增长50%

37、Hashtable和HashMap的区别联系

实现原理相同，功能相同，底层都是哈希表结构，查询速度快，在很多情况下可以互用

        两者的主要区别如下
        1)Hashtable是早期JDK提供的接口，HashMap是新版JDK提供的接口
        2)Hashtable继承Dictionary类，HashMap实现Map接口
        3)Hashtable线程安全，HashMap线程非安全
        4)Hashtable不允许null值，HashMap允许null值

38、Java主要容器的选择依据和应用场合

（1） HashTable,Vector类是同步的，而HashMap,ArrayList不是同步的。因此当在多线程的情况下,应使用HashTable和 Vector,相反则应使用HashMap,ArrayList.
（2）除需要排序时使用TreeSet,TreeMap外,都应使用HashSet,HashMap,因为他们的效率更高。
（3） ArrayList 由数组构建, LinkList由双向链表构建,因此在程序要经常添加,删除元素时速度要快些,最好使用
LinkList,而其他情况下最好使用ArrayList.因为他提供了更快的随机访问元素的方法。

show your code,say is esay