深入理解Java中的容器
1、容器的概念
在Java当中，如果有一个类专门用来存放其它类的对象，这个类就叫做容器，或者就叫做集合，集合就是将若干性质相同或相近的类对象组合在一起而形成的一个整体
2、容器与数组的关系
之所以需要容器：
1、数组的长度难以扩充
2、数组中数据的类型必须相同
容器与数组的区别与联系：
1、容器不是数组，不能通过下标的方式访问容器中的元素
2、数组的所有功能通过Arraylist容器都可以实现，只是实现的方式不同
3、如果非要将容器当做一个数组来使用，通过toArraylist方法返回的就是一个数组
示例程序：
package IT;
import java.util.ArrayL
import java.util.I
public class App
public static void main(String[] args)
ArrayList&Integer& arrayList = new ArrayList&Integer&();
arrayList.add(12);
arrayList.add(10);
arrayList.add(35);
arrayList.add(100);
Iterator&Integer& iterator = arrayList.iterator();
while(iterator.hasNext())
Integer value = iterator.next();
System.out.println(value);
System.out.println("通过ArrayList容器获取一个数组arr：");
Object[] arr = arrayList.toArray();
for(int i=0;i&arr.i++)
System.out.println(arr[i]);
输出结果：
通过ArrayList容器获取一个数组arr：
3、容器常用的几个方法
boolean add(Object obj):向容器中添加指定的元素
Iterator iterator（）：返回能够遍历当前集合中所有元素的迭代器
Object[] toArray():返回包含此容器中所有元素的数组。
Object get（int index）：获取下标为index的那个元素
Object remove（int index）：删除下标为index的那个元素
Object set（int index,Object element）：将下标为index的那个元素置为element
Object add（int index,Object element）：在下标为index的位置添加一个对象element
Object put(Object key,Object value):向容器中添加指定的元素
Object get（Object key）：获取关键字为key的那个对象
int size():返回容器中的元素数
实例程序：
package IT
import java.util.ArrayList
public class App
public static void main(String[] args)
ArrayList&Integer& arrayList = new ArrayList&Integer&()
arrayList.add(12)
arrayList.add(10)
arrayList.add(35)
arrayList.add(100)
System.out.println("原容器中的元素为:")
System.out.println(arrayList)
System.out.println("\n")
System.out.println("将下标为1位置的元素置为20,将下标为2位置的元素置为70")
arrayList.set(1, 20)
arrayList.set(2, 70)
System.out.println("重置之后容器中的元素为:")
System.out.println(arrayList)
System.out.println("\n")
System.out.println("在下标为1的位置插入一个元素,-----插入元素：此时容器后面的元素整体向后移动")
arrayList.add(1, 80)
System.out.println("插入之后容器中的元素为:")
System.out.println(arrayList)
System.out.println("插入之后容器中的容量为:")
System.out.println(arrayList.size())
System.out.println("\n")
System.out.println("将下标为3位置的元素70删除,-----删除元素:此时容器位置后面的元素整体向前移")
arrayList.remove(3)
System.out.println("删除之后容器中的元素为:")
System.out.println(arrayList)
System.out.println("删除之后容器中的容量为:")
System.out.println(arrayList.size())
运行结果：
原容器中的元素为:
[12, 10, 35, 100]
将下标为1位置的元素置为20,将下标为2位置的元素置为70
重置之后容器中的元素为:
[12, 20, 70, 100]
在下标为1的位置插入一个元素,插入元素：此时容器后面的元素整体向后移动
插入之后容器中的元素为:
[12, 80, 20, 70, 100]
插入之后容器中的容量为:
将下标为3位置的元素70删除,删除元素:此时容器位置后面的元素整体向前移
删除之后容器中的元素为:
[12, 80, 20, 100]
删除之后容器中的容量为:
4、容器的分类
容器分为Set集、List列表、Map映射
Set集合：由于内部存储结构的特点，Set集合中不区分元素的顺序，不允许出现重复的元素，TreeSet容器特殊，元素放进去的时候自然而然就有顺序了，Set容器可以与数学中的集合相对应：相同的元素不会被加入
List列表：由于内部存储结构的特点，List集合中区分元素的顺序，且允许包含重复的元素。List集合中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素—有序，可以重复
Map映射：由于内部存储结构的特点，映射中不能包含重复的键值，每个键最多只能映射一个值，否则会出现覆盖的情况(后面的value值会将前面的value值覆盖掉)，Map是一种把键对象和值对象进行映射的集合，即Map容器中既要存放数据本身，也要存放关键字:相同的元素会被覆盖
注意：对于Set和Map来说,元素放进去之后是没有顺序的，如果希望元素放进去之后是有顺序的，可以用treeSet和treeMap存储数据。
实例程序：
var set2 = mutable.Set.empty[Int]
set2 += 10
set2 ++= List(50,100,200)
set2 += 500
println("Set输出的结果：")
println(set2)
var map3 = mutable.Map.empty[String,Double]
map3 += "Spark"-&90.0
map3 += "Hadoop"-&80.0
map3 ++= List("Scala"-&100.0,"Java"-&60.0)
println("Map输出的结果：")
println(map3)
运行结果：
Set输出的结果：
Set(100, 50, 500, 10, 200)
Map输出的结果：
Map(Hadoop -& 80.0, Spark -& 90.0, Scala -& 100.0, Java -& 60.0)
实例程序：
var treeSet = TreeSet(10,20,30,90,100,200,50)
println(treeSet)
/*键值对排序是根据key的值进行排序的,没有value的事情,让我联想到了MapReduce中排序的时候之所以根据k2
而不是v2的值进行排序,这是因为哈希映射内部决定的，而不是MapReduce决定的
呵呵！注意：排序区分大小写的哦！！！*/
var treeSet2 = TreeSet[String]("Spark","Anang","Baby","Hello")
println(treeSet2)
var treeMap = TreeMap[String,Integer]("Java"-&100,"Scala"-&88,"Python"-&60,"Anglebaby"-&500)
println(treeMap)
运行结果：
TreeSet(10, 20, 30, 50, 90, 100, 200)
TreeSet(Anang, Baby, Hello, Spark)
Map(Anglebaby -& 500, Java -& 100, Python -& 60, Scala -& 88)
5、toString()方法的使用：凡是把类对象放到容器中，相应的类都应该实现Object类中的toString()方法；凡是Java中自带的数据类型，都已经重写完了toString()方法
实例1：(未重写toString()方法之前)
package IT;
public class App
public static void main(String[] args)
System.out.println("-----凡是Java中自带的数据类型都已经重写完了toString()方法！---");
System.out.println(new Integer(2).toString());
System.out.println(new String("zhang").toString());
System.out.println(new Student("zhangsan",99.8).toString());
class Student
public double
public Student(String name,double score)
this.name =
this.score =
输出结果：
实例2：(重写完toString()方法之后)
package IT;
import java.util.ArrayL
public class App
public static void main(String[] args)
ArrayList&Student& arr = new ArrayList&Student&();
arr.add(new Student("zhangsan",89.8));
arr.add(new Student("lisi",90));
arr.add(new Student("wangwu",60.6));
System.out.println(arr);
class Student
public double
public Student(String name,double score)
this.name =
this.score =
public String toString()
return this.name+"\t"+this.
输出结果：
89.8, lisi
90.0, wangwu
6、Comparable接口中的compareTo()方法:凡是需要进行比较排序的类都应该实现Comparable接口中的compareTo()方法；凡是把类对象放到以树为内部结构的容器中都应该实现Comparable接口中的compareTo()方法
package IT;
import java.util.ArrayL
import java.util.C
public class App
public static void main(String[] args)
ArrayList&Student& arr = new ArrayList&Student&();
arr.add(new Student("zhangsan",89.8));
arr.add(new Student("lisi",90));
arr.add(new Student("wangwu",60.6));
arr.add(new Student("wangting",85.6));
Collections.sort(arr);
for (Student student : arr)
System.out.println(student);
class Student implements
Comparable&Student&
public double
public Student(String name,double score)
this.name =
this.score =
public String toString()
return this.name+"\t"+this.
public int compareTo(Student obj)
return (int) (this.score - obj.score);
输出结果：
package IT;
import java.util.TreeS
public class App
public static void main(String[] args)
TreeSet&Student& treeSet = new TreeSet&Student&();
treeSet.add(new Student("wangwu",60.6));
treeSet.add(new Student("lisi",90.0));
treeSet.add(new Student("wangting",85.6));
treeSet.add(new Student("zhangsan",60.6));
for (Student student : treeSet)
System.out.println(student);
class Student implements
Comparable&Student&
public double
public Student(String name,double score)
this.name =
this.score =
public String toString()
return this.name+"\t"+this.
public int compareTo(Student obj)
if(this.score & obj.score)
return -1;
输出结果：
7、凡是把类对象放到以哈希表为内部存储结构的容器中，相应的类必须要实现equals方法和hashCode方法，这样才符合哈希表真实的逻辑功能.
实例程序1：(为重写之前)
package IT;
import java.util.HashM
import java.util.I
import java.util.S
public class App
public static void main(String[] args)
System.out.println("先测试Java中自带的数据类型:");
HashMap&String, Double& hashMap1 = new HashMap&String,Double&();
hashMap1.put("zhangsan", 96.0);
hashMap1.put("lisi", 88.6);
hashMap1.put("wangwu", 98.6);
hashMap1.put("wangting",
hashMap1.put("zhangsan", 96.0);
hashMap1.put("lisi", 88.6);
hashMap1.put("wangwu", 98.6);
hashMap1.put("wangting",
Set&String& keySet = hashMap1.keySet();
Iterator&String& iterator = keySet.iterator();
while(iterator.hasNext())
String key = iterator.next();
System.out.println(key+"\t"+hashMap1.get(key));
System.out.println("Java中自带的数据类型:相同的对象会覆盖！");
System.out.println("\n");
System.out.println("测试用户自定义的数据类型--未重写两个方法之前:");
HashMap&Student, String& hashMap2 = new HashMap&Student,String&();
hashMap2.put(new Student("zhangsan",88.8), "beijing");
hashMap2.put(new Student("lisi",88.8), "beijing");
hashMap2.put(new Student("wangwu",66.9), "beijing");
hashMap2.put(new Student("zhangsan",88.8), "beijing");
hashMap2.put(new Student("lisi",88.8), "beijing");
hashMap2.put(new Student("wangwu",66.9), "beijing");
Set&Student& keySet2 = hashMap2.keySet();
Iterator&Student& iterator2 = keySet2.iterator();
while(iterator2.hasNext())
Student key = iterator2.next();
System.out.println(key+"\t"+hashMap2.get(key));
System.out.println("如果没有重写:导致相同的对象不会被覆盖!");
class Student implements
Comparable&Student&
public double
public Student(String name,double score)
this.name =
this.score =
public String toString()
return this.name+"\t"+this.
public int compareTo(Student obj)
if(this.score & obj.score)
return -1;
实例程序2:重写之后
package IT;
import java.util.HashM
import java.util.I
import java.util.S
public class App
public static void main(String[] args)
System.out.println("测试用户自定义的数据类型--重写两个方法之后:");
HashMap&Student, String& hashMap2 = new HashMap&Student,String&();
hashMap2.put(new Student("zhangsan",88.8), "beijing");
hashMap2.put(new Student("lisi",88.8), "beijing");
hashMap2.put(new Student("wangwu",66.9), "beijing");
hashMap2.put(new Student("zhangsan",88.8), "beijing");
hashMap2.put(new Student("lisi",88.8), "beijing");
hashMap2.put(new Student("wangwu",66.9), "beijing");
Set&Student& keySet2 = hashMap2.keySet();
Iterator&Student& iterator2 = keySet2.iterator();
while(iterator2.hasNext())
Student key = iterator2.next();
System.out.println(key+"\t"+hashMap2.get(key));
System.out.println("重写过后:相同的对象会被覆盖!");
class Student implements
Comparable&Student&
public double
public Student(String name,double score)
this.name =
this.score =
public String toString()
return this.name+"\t"+this.
public int compareTo(Student obj)
if(this.score & obj.score)
return -1;
public int hashCode()
return (int) (this.name.hashCode()*score);
public boolean equals(Object obj)
Student cc = (Student)
return this.name==cc.name&&this.score==cc.
8、重要的一个逻辑:逻辑上来讲，只要两个对象的内容相同，其地址(hashCode()返回值)以及这两个对象就应该相同(equals())，
实例程序(为重写之前):
package IT;
public class App
public static void main(String[] args)
System.out.println(new Integer(1).equals(new Integer(1)));
System.out.println(new Integer(1).hashCode()==new Integer(1).hashCode());
System.out.println(new String("zhang").equals(new String("zhang")));
System.out.println(new String("zhang").hashCode()==new String("zhang").hashCode());
System.out.println("\n");
System.out.println(new Student("zhangsan",98.8).equals(new Student("zhangsan",98.8)));
System.out.println(new Student("zhangsan",98.8).hashCode());
System.out.println(new Student("zhangsan",98.8).hashCode());
class Student implements
Comparable&Student&
public double
public Student(String name,double score)
this.name =
this.score =
public String toString()
return this.name+"\t"+this.
public int compareTo(Student obj)
if(this.score & obj.score)
return -1;
重写之后：
package IT;
public class App
public static void main(String[] args)
System.out.println(new Student("zhangsan",98.8).equals(new Student("zhangsan",98.8)));
System.out.println(new Student("zhangsan",98.8).hashCode());
System.out.println(new Student("zhangsan",98.8).hashCode());
class Student implements
Comparable&Student&
public double
public Student(String name,double score)
this.name =
this.score =
public String toString()
return this.name+"\t"+this.
public int compareTo(Student obj)
if(this.score & obj.score)
return -1;
public int hashCode()
return (int) (this.name.hashCode()*score);
public boolean equals(Object obj)
Student cc = (Student)
return this.name==cc.name&&this.score==cc.
上面的5、6、7、8可以归结为4个”凡是”，1个“逻辑”:
1、凡是把类对象放到容器中，相应的类都应该实现Object类中的toString()方法；
2、凡是需要进行比较排序的类都应该实现Comparable接口中的compareTo()方法；凡是把类对象放到以树为内部结构的容器中都应该实现Comparable接口中的compareTo()方法
3、凡是把类对象放到以哈希表为内部存储结构的容器中，相应的类必须要实现equals方法和hashCode方法，这样才符合哈希表真实的逻辑功能.
4、逻辑上来讲，只要两个对象的内容相同，其地址(hashCode()返回值)以及这两个对象就应该相同(equals())。
9、哈希冲突的相关概念
本质上讲就是:hash(对象1.hashCode())=hash2(对象2.hashCode())，即第一个对象的hashCode()方法返回的哈希码值带入到哈希函数后得到的索引位置与第二个对象的hashCode()方法返回的哈希码值带入到哈希函数后得到的索引位置相同，这就是哈希冲突。
最常见的哈希算法是取模法。
下面简单讲讲取模法的计算过程。
比如：数组的长度是5。这时有一个数据是6。那么如何把这个6存放到长度只有5的数组中呢。按照取模法，计算6％5，结果是1，那么就把6放到数组下标是1的位置。那么，7
就应该放到2这个位置。到此位置，哈斯冲突还没有出现。这时，有个数据是11，按照取模法，11％5＝1，也等于1。那么原来数组下标是1的地方已经有数了，是6。这时又计算出1这个位置，那么数组1这个位置，就必须储存两个数了。这时，就叫哈希冲突。冲突之后就要按照顺序来存放了。
如果数据的分布比较广泛，而且储存数据的数组长度比较大。
那么哈希冲突就比较少。否则冲突是很高的。
10、iterator接口的作用
boolean hasNext():是用来判断当前游标(迭代器)的后面是否存在元素，如果存在返回真，否则返回假
Object next()：先返回当前游标右边的元素，然后游标后移一个位置
void remove()：不推荐使用iterator的remove()方法，而是推荐使用容器自带的remove方法。
package IT
import java.util.HashMap
import java.util.Iterator
import java.util.Set
public class App
public static void main(String[] args)
HashMap&String, Double& hashMap = new HashMap&String,Double&()
hashMap.put("zhangsan", 88.6)
hashMap.put("lisi", 69.0)
hashMap.put("wanqwu", 100.0)
hashMap.put("lisi", 69.0)
Set&String& keySet = hashMap.keySet()
Iterator&String& iterator = keySet.iterator()
while(iterator.hasNext())
String key = iterator.next()
System.out.println(key+hashMap.get(key))
package IT;
import java.util.TreeS
public class App
public static void main(String[] args)
TreeSet&Student& treeSet = new TreeSet&Student&();
treeSet.add(new Student("zhangsan",98));
treeSet.add(new Student("zhangsan",98));
System.out.println(treeSet.size());
System.out.println(treeSet);
System.out.println(new Student("zhangsan",98).equals(new Student("zhangsan",98)));
class Student implements Comparable&Object&
public double
public Student(String name,double score)
this.name =
this.score =
public String toString()
return name + "\t" +
public int compareTo(Object obj)
Student cc = (Student)
return (int) (this.score - cc.score);
上面的讲解如有问题，欢迎留言指正！
没有更多推荐了，第一章第五关，打破每一个容器，是不是有隐藏的地方？
听说这里是没有做完的一个图
该帖子已被关闭回复
欢迎关注我们
一天一款全球精品游戏推荐，活跃的玩家交流社区
只收录官方包，不联运，支持安卓正版游戏购买
倡导真实评分评价，排行榜单来自玩家真实反馈
发现好游戏
二维码下载
请先后，再进行操作
便捷下载及更新游戏发现更多精彩游戏更丰富的社区动态高效找到感兴趣的游戏
微信&扫一扫&，点击有一部电影是讲机器人统治了人类，并把人类装在一个像卵一样的机器容器里，把人当做能源的，是什么电影？_百度知道
有一部电影是讲机器人统治了人类，并把人类装在一个像卵一样的机器容器里，把人当做能源的，是什么电影？
有一部电影是讲机器人统治了人类，并把人类装在一个像卵一样的机器容器里，把人当做能源的，是什么电影？还有能推荐几部像《豚鼠特工队》《极乐空间》这样的科幻电影吗
我有更好的答案
那部电影叫《黑客帝国》
推荐些好看的科幻电影给你：盗梦空间、阿凡达、机械公敌
采纳率：100%
骇客帝国吧……
我有科幻的，
我百度云，奥利奥没有夹心
等中考完再去看😂
应该是黑客帝国，
应该是机械公敌
你说的是黑客帝国！
毛线😂真当我没听过黑客帝国😂
听名字感觉不太想呀😂黑客帝国是讲这个的吗😂
黑客帝国应该没错
确实是😂
太晚了(ㅎ.ㅎ)
其他3条回答
为您推荐：
其他类似问题
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。(nichunlv)
(紫玄大师)
第三方登录：有一个手机游戏，记不住名字。记得把白色的小球放入容器中，还可以分裂。求名字！急急急急急！_百度知道
有一个手机游戏，记不住名字。记得把白色的小球放入容器中，还可以分裂。求名字！急急急急急！
我有更好的答案
微生物战争 Petri在培养皿这个充满敌意的世界，到处都是微观层面求生的微生物，为了生存，你可以选择分裂或扩大队伍，打败竞争对手和潜在的威胁。游戏画面非常炫彩，让微观世界变得五彩绚丽，玩家只要通过触摸屏幕即可控制自己的生物前往指定地点，通过吞噬食物，可以增大体型，游戏下方有一个成长条，一旦填满就可分裂扩张。偶尔会出现致命物和西塔生物，吞噬杀死或者逃避远离，这由你自己决定。是这个么
叫什么微生物来着
不思议微生物研究所
1条折叠回答
为您推荐：
其他类似问题
手机游戏的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。