// 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("\nArrayList\'s lastIndexOf(\"0\") is "
+ arraylist.lastIndexOf("0"));
}
// Arrays
{
String[] array = new String[] { "a", "b", "c" };
List list = Arrays.asList(array);
System.out.println("\nArrays:");
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + ";");
}
System.out.print("\nArrays\'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("\nCollections:");
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("\n" + 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("\nHashSet:");
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("\nHashtable:");
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("\nIdentityHashMap:");
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("\nLinkedHashSet:");
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("\nLinkedList:");
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("\nStack:");
while (enumeration.hasMoreElements()) {
System.out.print(enumeration.nextElement() + ";");
}
// 后进先出
System.out.println("\n" + 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("\nTreeMap:");// 可以对键排序
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("\nTreeSet:");
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("\nVector:");
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("\n" + 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("\nWeakHashMap:");
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");//获取指定键的值
}
分享到：
相关推荐
### 集合概述：set、List、Map #### 一、集合框架概述 ##### 1.1.1 容器简介 在Java编程中，集合框架是一个非常重要的概念，它提供了一种灵活的方式来存储、操作和管理不同类型的对象集合。集合框架的主要目标是...
根据给定文件的信息，我们可以详细地探讨一下Java中几种主要的集合容器——List、Set以及Map的区别，并且深入了解它们各自的特性和应用场景。 ### 一、List #### 1. ArrayList - **特点**：`ArrayList`是基于动态...
本教程将深入探讨三种主要的集合类型：List、Set和Map，以及几种常用的循环语句，如forEach、map、where、any和every。这些概念对于理解Dart中的数据处理至关重要。 1. **List**： List是有序的元素集合，可以包含...
对于这些集合类，深入理解它们的源码对于优化代码和解决问题至关重要。例如，了解ArrayList如何扩容，LinkedList如何实现添加和删除操作，以及HashMap和TreeMap如何实现快速查找和保持数据结构的平衡。 5. **工具...
在Java编程语言中，集合框架提供了多种数据结构来存储和操作数据，其中最常用的是`Set`、`Map`和`List`。这三种集合类型各自具有独特的特性和用途，理解它们之间的区别与联系对于有效地使用Java进行数据管理至关重要...
本文将深入探讨Java集合框架中的四个主要接口：Collection、List、Set和Map，以及它们的实现原理。 ### 集合框架概述 集合框架是Java API中用于存储和管理对象的统一框架。它为数据结构提供了抽象接口，使得程序员...
Java 集合框架中 List、Set、Map 的用法和区别 Java 集合框架（Java Collections Framework）是 Java 语言中的一个重要组件，提供了一些基本的数据结构和算法来操作和存储数据。其中，List、Set、Map 是三个非常...
在Java编程语言中，集合框架是处理对象的重要工具，其中包括Set、List和Map三大接口。这些接口提供了多种数据结构和操作方法，使得开发者能够高效地组织和管理数据。 1. **Set接口**： Set接口表示一个不包含重复...
本文将深入探讨List和Set在使用`retainAll`方法时的效率差异，并通过`ListAndRetainAll.java`和`SetAndRetainAll.java`两个示例代码来具体分析。 首先，让我们了解`retainAll`方法的基本概念。`retainAll`是Java...
本篇文章将详细介绍如何将Map和List集合转换为XML字符串，以及如何将XML字符串反向转换回Map和List集合。 首先，让我们探讨`Map`集合转成XML字符串的过程。一个`Map`对象存储键值对，可以使用各种库如`JAXB (Java ...
Java 集合类 List-Set-Map 的区别和联系 Java 集合类 List、Set 和 Map 是 Java 语言中最基本的集合类，它们之间存在着紧密的联系和区别。在本文中，我们将对 Java 集合类 List、Set 和 Map 的区别和联系进行详细的...
本篇文章将深入探讨集合框架中的三大核心组件：`List`、`Set`以及`Map`，并通过具体的接口和类来分析它们的特点和应用场景。 #### 集合接口 在Java集合框架中，主要有以下几种关键接口： - **`Collection`接口**：...
在Java编程语言中，集合框架是处理对象组的重要工具，主要包括List、Set和Map三大接口。这些接口由Java Collection Framework提供，它是一个统一的架构，用于存储和操作各种类型的对象。接下来，我们将深入探讨这三...
本文将深入解析Java集合中的Collection、List、Set和Map，包括它们的使用方法、实现原理以及如何进行排序。 ### 集合框架概述 1.1.1 容器简介 容器是Java集合框架的基础，它是一个可以存储多个对象的容器，提供了...
"Java集合Collection、List、Set、Map使用详解" Java集合是Java编程语言中最基本也是最重要的一部分。能够正确地使用集合类和理解集合的实现原理对于Java程序的开发具有无比的好处。本文将详细解释Java集合的实现...
在Java编程语言中，`set`、`list`和`map`是非常重要的数据结构，它们分别代表了不同的集合类型，各自有着独特的特性与用途。 - **List**：有序集合，可以包含重复元素。 - **Set**：不允许重复元素的集合，不保证...
在Java编程语言中，集合框架是数据操作的核心部分，它提供了对对象的高效存储和管理。其中，`Collection`、`List`、`Set`和`Map`是四大基本接口，它们各自代表了一种特定的数据结构，有着不同的特性和用途。下面我们...
Collection, List, Set 和 Map 用法和区别 Collection 是 Java 中的一种对象...Collection、List、Set 和 Map 等集合类是 Java 中非常重要的一部分，需要深入了解其用法和区别，以便更好地使用集合类来实现业务逻辑。
在Java编程语言中，`List`、`Set`和`Map`是集合框架中的三个核心接口，它们分别代表了不同类型的集合数据结构，各自有着独特的特性和应用场景。 #### List `List`接口是最常用的集合之一，它允许重复元素，并且每个...