huangsky
- 浏览: 39529 次
- 性别:
- 来自: 深圳
-
文章分类
最新评论
public class JAVAContainer {
public static void main(String[] args) throws Exception {
// ArrayList
{
ArrayList arraylist = new ArrayList();
arraylist.add(0, "end");//指定索引加入值
// 需注意的是，如果现有2个值，我加入索引为5的那么就会出现异常
for (int i = 0; i < 2; i++) {
arraylist.add(i, String.valueOf(i));
}
System.out.println("ArrayList:");
for (int i = 0; i < arraylist.size(); i++) {
System.out.print(arraylist.get(i) + ";");
}
arraylist.add("0");//直接加入值到ArrayList的最后
arraylist.add("0");
System.out.print(" ArrayList's lastIndexOf("0") is "
+ arraylist.lastIndexOf("0"));
}
// Arrays
{
String[] array = new String[] { "a", "b", "c" };
List list = Arrays.asList(array);
System.out.println(" Arrays:");
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + ";");
}
System.out.print(" Arrays's length is " + array.length);//打印数组的长度
}
// Collections
{
String[] array = new String[] { "a", "b", "c" };
List list = Arrays.asList(array);
Collections.fill(list, "Fill");//用Fill填充全部元素
System.out.println(" Collections:");
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + ";");
}
array = new String[] { "1", "2", "3" };
List list2 = Arrays.asList(array);
Collections.copy(list, list2);//拷贝list2的数据进list
System.out.println(" " + list);
Collections.swap(list, 2, 1);//调换索引为1和2的元素的位置
System.out.println(list);
}
// EventObject
{
String s = "hello";
String s2 = s;
EventObject eventobject = new EventObject(s);//一个准容器类型，确切的归类它不是容器
System.out.println("EventObject:");
System.out.println(eventobject.getSource());
System.out.println(eventobject.equals(s2));
}
// HashMap
{
HashMap hashmap = new HashMap();//一个速度最快的容器
hashmap.put("0", "c");
hashmap.put("1", "a");
hashmap.put("2", "b");
hashmap.put("3", "a");
System.out.println("HashMap:");
System.out.println(hashmap);//该容器有其内部的排序方式
Set set = hashmap.keySet();//获取全部键
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.print(hashmap.get(iterator.next()) + ";");
}
}
// HashSet
{
HashSet hashset = new HashSet();//一个绝对不能重复的类型
hashset.add("c");
hashset.add("b");
hashset.add("a");
hashset.add("a");
hashset.add("b");
System.out.println(" HashSet:");
System.out.println(hashset);
Iterator iterator = hashset.iterator();//取出元素
while (iterator.hasNext()) {
System.out.print(iterator.next() + ";");
}
}
// Hashtable
{
Hashtable hashtable = new Hashtable();//一个完全可以由其他容器替换的老容器类型
hashtable.put("0", "c");
hashtable.put("1", "a");
hashtable.put("3", "c");
hashtable.put("2", "b");
System.out.println(" Hashtable:");
Enumeration enumeration = hashtable.elements();//获取元素，Enumeration已经不是主流，Iterator是它的下一代替代品
while (enumeration.hasMoreElements()) {
System.out.print(enumeration.nextElement() + ";");
}
}
// IdentityHashMap
{
IdentityHashMap identityhashmap = new IdentityHashMap();
identityhashmap.put("0", "c");
identityhashmap.put("1", "a");
identityhashmap.put("3", "b");
identityhashmap.put("2", "a");
System.out.println(" IdentityHashMap:");
System.out.println(identityhashmap);
System.out.println(identityhashmap.containsKey("3"));//是否包含这个键
System.out.println(identityhashmap.containsValue("a"));//是否包含值
Set set = identityhashmap.entrySet();//传为Set类型
System.out.println(set);
set = identityhashmap.keySet();//全部键
System.out.println(set);
}
// LinkedHashMap
{
LinkedHashMap linkedhashmap = new LinkedHashMap();
linkedhashmap.put("0", "b");
linkedhashmap.put("2", "a");
linkedhashmap.put("1", "c");
linkedhashmap.put("3", "b");
System.out.println("LinkedHashMap:");
System.out.println(linkedhashmap);
System.out.println(linkedhashmap.containsKey("2"));//是否包含这个键
System.out.println(linkedhashmap.containsValue("c"));//是否包含值
Set set = linkedhashmap.keySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.print(linkedhashmap.get(iterator.next()) + ";");
}
}
// LinkedHashSet
{
LinkedHashSet linkedhashset = new LinkedHashSet();//它包含了几种Set的属性但却没有自己的特色
linkedhashset.add("c");
linkedhashset.add("a");
linkedhashset.add("a");
linkedhashset.add("b");
System.out.println(" LinkedHashSet:");
System.out.println(linkedhashset);
System.out.println(linkedhashset.contains("a"));//是否包含对象
Iterator iterator = linkedhashset.iterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + ";");
}
}
// LinkedList
{
LinkedList linkedlist = new LinkedList();//自由使用是它的特色
linkedlist.add("a");
linkedlist.add(1, "c");
linkedlist.addLast("b");
linkedlist.addFirst("d");
System.out.println(" LinkedList:");
System.out.println(linkedlist);
// linkedlist.clear();//该方法清空容器
// linkedlist.remove(0);//删除索引为0的元素
// linkedlist.remove("d");//删除值为d的元素
// linkedlist.removeFirst();//删除第一个元素
// linkedlist.removeLast();//删除最后一个元素
for (int i = 0; i < linkedlist.size(); i++) {
System.out.print(linkedlist.get(i) + ";");
}
}
// Stack
{
Stack stack = new Stack();//堆栈
stack.add("b");
stack.add(0, "c");
stack.push("d");
stack.add("e");
stack.push("a");
Enumeration enumeration = stack.elements();
System.out.println(" Stack:");
while (enumeration.hasMoreElements()) {
System.out.print(enumeration.nextElement() + ";");
}
// 后进先出
System.out.println(" " + stack.peek());
System.out.println(stack.pop());
System.out.println(stack.contains("d") + ";" + stack.contains("a"));//是否包含该元素,有趣的事情发生了
System.out.println(stack.search("c"));//非常有用的属性，检索，但是由后向前的排列
}
// TreeMap
{
TreeMap treemap = new TreeMap();
treemap.put("0", "d");
treemap.put("2", "a");
treemap.put("1", "b");
treemap.put("3", "c");
System.out.println(" TreeMap:");//可以对键排序
System.out.println(treemap);
System.out.println(treemap.firstKey());//返回第一个键
Set set = treemap.keySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.print(treemap.get(iterator.next()) + ";");
}
}
// TreeSet
{
TreeSet treeset = new TreeSet();//自动排序内容
treeset.add("b");
treeset.add("a");
treeset.add("c");
treeset.add("d");
System.out.println(" TreeSet:");
System.out.println(treeset);
System.out.println(treeset.first());//返回第一个元素
Iterator iterator = treeset.iterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + ";");
}
}
// Vector
{
Vector vector = new Vector();
vector.add(0, "b");
vector.add("a");
vector.addElement("d");
vector.add("c");
System.out.println(" Vector:");
System.out.println(vector);
vector.set(2, "h");//替换掉指定索引的元素
System.out.println(vector);
Object[] str = vector.toArray();
for (int i = 0; i < str.length; i++) {
System.out.print(str[i] + ";");
}
vector.setSize(2);//重新设置大小为2
System.out.println(" " + vector);
}
// WeakHashMap
{
WeakHashMap weakhashmap = new WeakHashMap();
weakhashmap.put("1", "b");
weakhashmap.put("2", "c");
weakhashmap.put("0", "d");
weakhashmap.put("3", "a");
System.out.println(" WeakHashMap:");
System.out.println(weakhashmap);
System.out.println(weakhashmap.containsKey("3"));//是否包含键
System.out.println(weakhashmap.containsValue("d"));//是否包含值
Set set = weakhashmap.entrySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + ";");
}
// weakhashmap.remove("2");//删除该键对应的值
// weakhashmap.get("1");//获取指定键的值
}
}
}
JAVA提高认识Set集合之HashSet：
集合在Java里面的作用非凡，我们常用的有Set,List和Map三种，我们先熟悉一下Set，特别是HashSet的使用
package collection.lession2;
import java.util.HashSet;
import java.util.Set;
/**
* 认识Set集合之HashSet。<br>
* Set用来保存不允许重复的数据。可以是任何对象类型。<br>
* JDK5以后，主类型可以通过autobox 放入Set里面。
*
*
*/
public class Lession2 {
public static void main(String[] args) {
// 普通测试
testNormal();
// 测试HashSet的特殊性
testForHashSet();
testForHashSet2();
}
/**
* 测试保存混合类型的数据.
*/
public static void testNormal() {
System.out.println("----- testNormal -----------");
// Set有多个实现，我们先看看最常用的HashSet
Set set = new HashSet();
// 添加一个字符串
set.add("字符串");
// 添加一个整数对象
set.add(new Integer(1));
// 利用JDK5的特性，增加一个浮点数
set.add(123.45);
// 我们看看集合里对象的数量
System.out.println(set.size());
// 我们尝试增加一个重复的字符串
set.add("字符串");
// 我们再次看看集合里对象的数量
System.out.println(set.size());
// 我们来测试看看是否集合里包含了某个数据
System.out.println(set.contains(123.45));
// 我们从里面把这个浮点数删除
set.remove(123.45);
// 我们再次看看集合里对象的数量
System.out.println(set.size());
}
/**
* 专门针对HashSet的测试。
*/
public static void testForHashSet() {
System.out.println("----- testForHashSet -----------");
HashSet<MyObject> set = new HashSet<MyObject>();
// 增加一个null对象
set.add(null);
// 我们再次看看集合里对象的数量
System.out.println(set.size());
// 再次增加一个null看看
set.add(null);
// 我们再次看看集合里对象的数量
System.out.println(set.size());
MyObject obj = new MyObject("java2000", 2);
set.add(obj);
obj = new MyObject("csdn", 10);
set.add(obj);
// 我们再次看看集合里对象的数量
System.out.println(set.size());
// 判断是否包含某个对象
System.out.println(set.contains(obj));
obj = new MyObject("java2000_net", 2);
set.add(obj);
// 我们再次看看集合里对象的数量
System.out.println(set.size());
// 我们尝试把obj再次放入set看看
// 并没有增加，因为是重复的
set.add(obj);
System.out.println(set.size());
// 我们构造一个新的对象，内容和前面的相同
obj = new MyObject("java2000_net", 2);
set.add(obj);
System.out.println(set.size());
// 我们修改一下obj里面的年龄，再看看
obj.setAge(3);
// 我们再测试看看是否包含此对象。
// 请注意，我们这个obj和前面的obj是同一个对象
&nbs-p; // 我们仅仅修改了一下我们的年龄
System.out.println(set.contains(obj));
// 我们尝试把obj再次放入set看看
// 我们又增加了长度
set.add(obj);
System.out.println(set.size());
}
/**
* 专门针对HashSet的测试2。
*/
public static void testForHashSet2() {
System.out.println("----- testForHashSet2 -----------");
HashSet<MyObject2> set = new HashSet<MyObject2>();
MyObject2 obj = null;
for (int i = 0; i < 3; i++) {
obj = new MyObject2("java2000" + i, i);
set.add(obj);
System.out.println(set.size());
}
}
}
class MyObject {
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
MyObject(String name, int age) {
this.name = name;
this.age = age;
}
public boolean equals(Object obj) {
System.out.println("equals");
if (obj == null || !(obj instanceof MyObject)) {
return false;
}
MyObject o = (MyObject) obj;
return this.age == o.age && this.name.equals(o.name);
}
public int hashCode() {
int hashCode = name.hashCode() + String.valueOf(age).hashCode();
return hashCode;
}
}
class MyObject2 {
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
MyObject2(String name, int age) {
this.name = name;
this.age = age;
}
public boolean equals(Object obj) {
System.out.println("equals");
if (obj == null || !(obj instanceof MyObject2)) {
return false;
}
MyObject2 o = (MyObject2) obj;
return this.age == o.age && this.name.equals(o.name);
}
pan class="keyword">int hashCode() {
return 1;
}
}
class MyObject3 {
private int age;
private String name;
// 采用一个变量进行控制
// 一旦生成了hashCode,则不再变动
private int HASHCODE = Integer.MIN_VALUE;
public int hashCode() {
if (HASHCODE == Integer.MIN_VALUE) {
// 重新生成本类的hashCode
HASHCODE = name.hashCode() + String.valueOf(age).hashCode();
}
return HASHCODE;
}
}
说明,针对HashSet：
Set不允许重复
允许 null,重复的null只算一个
判断是否存在一个数据(是否重复)，先判断其hashCode是否存在，若存在再逐个判断hashCode相同的数据是否相等
判断是否相等，除了hashCode相等外，还要判断对象引用相等(==)，或者 equals
如果一个对象的hashCode变动了，会造成找不到这个对象，也就出现了内存泄漏的危险。
hashCode 方法是HashSet里面对象的关键，它的算法影响到了数据的分散和查找效率。某个确认对象的hashCode不应该变动，避免出现内存泄漏，可以采用如下方法，来方式属性变化造成hashCode变化
class MyObject3 {
private int age;
private String name;
// 采用一个变量进行控制
// 一旦生成了hashCode,则不再变动
private int HASHCODE = Integer.MIN_VALUE;
public int hashCode() {
if (HASHCODE == Integer.MIN_VALUE) {
// 重新生成本类的hashCode
HASHCODE = name.hashCode() + String.valueOf(age).hashCode();
}
return HASHCODE;
}
}
分享到：
发表评论
-
poi BigGridDemo
2013-07-05 09:04 974import java.io.*; import j ... -
mysql去除重复
2012-11-27 18:09 939今天在做个联系人功能时，要做导入去重复的功能 假设有10万个联 ... -
定时器
2012-01-30 11:40 973现在常用到两种定时器，做下备忘 有Spring的 < ... -
Struts标签之<s:optiontransferselect/>
2011-05-16 12:27 1728<s:optiontransferselect n ... -
test
2011-04-28 14:39 0testtest -
ant 找不到符号
2011-04-27 11:39 4241第一次用ANT打包，报找不到符号，找不到类，大部分是 ja ... -
Base64Coding
2010-12-17 10:08 979由于环境原因，经常使用HTTP或WebService接口，BA ... -
WebService备忘
2010-11-26 14:42 7841,new webservice project 2,new ... -
ibatis的模糊查询 like
2010-11-25 14:00 937<isNotNull prepend=" ... -
java解析XML
2010-11-15 17:47 899package resource; import jav ... -
一个LIST中的重复与不重复
2010-10-21 16:37 2067去掉一个LIST的重复 Set someSet = new H ... -
Struts2标签 增加序号列
2010-09-28 10:36 2109有的时候由于特殊需要，得在列前再多一列序号列,用Struts2 ... -
MAP传参需仔细
2010-09-19 18:04 1202在PO中 private Date birthday; ... -
struts2 格式化数字,可扩展四舍五入
2010-08-06 08:38 1918struts.properties中添加 FormatNume ... -
HTTP Status 404 - No result defined for action
2010-08-02 17:42 1791No result defined for action an ...
相关推荐
这篇学习笔记将深入探讨Java集合框架的基础概念、主要类库以及常见应用场景。 首先，Java集合框架分为两种基本类型：List（列表）和Set（集）。List接口代表有序的集合，允许重复元素，如ArrayList和LinkedList；而...
集合是Java编程中重要的数据结构，它主要用于存储一组不重复的数据。集合分为单列集合（Collection）和双列集合（Map）。...理解这些集合的特点和操作，能帮助我们更好地设计和实现各种数据结构和算法。
【标题】"笔记集合.rar" 是一个压缩文件，包含了作者整理的各种IT学习笔记，主要涵盖了Java编程语言、小程序开发以及SQL数据库操作等多个技术领域。这个压缩包可以视为一个丰富的知识库，供学习者参考和使用。 ...
【Java集合】 Java集合框架是Java编程语言中用于存储和操作对象的工具，它提供了多种数据结构，如列表、集、映射等，以适应不同的数据处理需求。集合类通常位于`java.util`包下，是Java程序员必备的知识点。 1. **...
List set ArraryList Map java集合框架笔记 基于Array的List，其实就是封装了Array所不具备的一些功能方便我们使用
### Map集合概述与特点 #### 一、Map集合的特点及概念 Map集合是Java集合框架中的重要组成部分之一，主要用于存储键值对（key-value pairs）。它与Collection接口不同，Collection接口用于存储单个对象，而Map接口...
Java集合框架是Java编程语言中一个至关重要的组成部分，它提供了数据结构和算法的抽象，使得开发者可以方便地存储和管理各种类型的数据。本篇将详细探讨Java集合框架的基础知识，包括核心接口、类的层级结构以及Java...
JUnit知识点滴集合笔记，这个包里面包括了好几篇文档，一定会让你对JUNIT有一个全新的认识。 JUnit 4 抢先看.doc JUnit in java 真正的测试用例实战.doc JUnit起步.doc junit实现过程.doc JUnit中如何测试异常.doc ...
集合论与图论是数学中的两个基础分支，广泛应用于数学逻辑、计算机科学、统计学等众多领域。集合论研究的是集合和集合之间的关系、运算、性质等，而图论则专注于图的结构以及图上可以定义的种种概念和性质。以下是...
SET集合笔记.md复习11.7
标题中的“传智播客课件笔记集合”指的是一个综合性的学习资源包，包含了传智播客教育机构的多个课程资料。传智播客是一家知名的IT培训机构，专注于提供高质量的编程和技术培训，其课程覆盖了从基础到高级的各类IT...
这份"java中的集合笔记"涵盖了这些关键概念。 1. **集合接口** - **List**: List接口代表一个有序的集合，允许有重复元素。ArrayList和LinkedList是其主要实现类。ArrayList基于动态数组，提供了快速访问但插入和...
Java集合学习笔记.pdf
自学java，写的集合笔记.xmind
Java集合源码笔记记录
这份“java笔记集合”涵盖了从基础到进阶的各种主题，旨在帮助初学者快速掌握Java编程的核心概念和技术。以下是对这些笔记内容的详细解读： 1. **Java基础**：这部分笔记可能包括Java语法基础，如变量、数据类型、...
这些知识点通过图像文件的形式呈现，可能是各种图表、代码示例或解构图，帮助学习者更好地理解和记忆Java集合框架的核心概念。在实际的学习过程中，结合这些图片和文字笔记，可以加深对Java集合的理解，提升编程能力...
10. 数据类型详解-集合笔记 - 副本
### 数组和集合的学习笔记 #### 一、概述 在Java编程语言中，数组和集合是数据存储与操作的重要组成部分。数组是一种基本的数据结构，用于存储相同类型的数据元素；而集合（Collections）则是用于存储、检索和操作...