完整代码中包含以下所有的集合操作
数组转集合、集合转数组
集合比较
HashMap遍历
集合长度
集合打乱顺序
集合遍历
集合反转
删除集合中指定元素
只读集合
集合输出
List 循环移动元素
查找 List 中的最大最小值
遍历 HashTable 的键值
使用 Enumeration 遍历HashTable
List 截取
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;
public class Demo {
public static void main(String[] args) {
int n = 5; // 5个元素
String[] name = new String[n];
for (int i = 0; i < n; i++) {
name[i] = String.valueOf(i);
}
// 使用 Java Util 类的 Arrays.asList(name) 方法将数组转换为集合
List<String> list = Arrays.asList(name);
System.out.println(list); // 输出集合
// 使用 Java Util 类的 list.toArray() 方法将集合转为数组
String[] name1 = list.toArray(new String[0]);
for (int i = 0; i < name1.length; i++)
System.out.println(name1[i]); // 输出数组
// for循环输出集合元素
// for (String li : list) {
// String str = li;
// System.out.print(str + " ");
// }
String[] coins = { "Penny", "nickel", "dime", "Quarter", "dollar" };
Set<String> set = new TreeSet<String>();
// 将字符串转换为集合
for (int i = 0; i < coins.length; i++) {
set.add(coins[i]);
}
System.out.println(set);
// 使用 Collection 类的 Collection.min() 和 Collection.max() 来比较集合中的元素
System.out.println(Collections.min(set));
System.out.println(Collections.min(set, String.CASE_INSENSITIVE_ORDER));
System.out.println(Collections.max(set));
System.out.println(Collections.max(set, String.CASE_INSENSITIVE_ORDER));
// 使用 Collection 类的 iterator() 方法来遍历集合
HashMap<String, String> hMap = new HashMap<String, String>();
hMap.put("1", "1st");
hMap.put("2", "2nd");
hMap.put("3", "3rd");
Collection<String> cl = hMap.values();
Iterator<String> itr = cl.iterator();
while (itr.hasNext()) {
System.out.println(itr.next());
}
// 使用 Collections 类 Collections.shuffle() 方法来打乱集合元素的顺序
List<Integer> list1 = new ArrayList<Integer>();
for (int i = 0; i < 10; i++)
list1.add(new Integer(i));
System.out.println("打乱前:");
System.out.println(list1);
for (int i = 0; i < 3; i++) {
System.out.println("第" + (i + 1) + "次打乱：");
Collections.shuffle(list1);
System.out.println(list1);
}
// List集合的遍历
listTest();
// Set集合的遍历
setTest();
// 集合反转
String[] a = { "A", "B", "C" };
revTest(a);
// 删除集合中指定元素
remTest();
// 只读集合
unmTest();
// 集合输出
outTest();
// List 循环移动元素
List<String> rot = Arrays.asList("one Two three Four five six".split(" "));
System.out.println("List :" + rot);
Collections.rotate(rot, 3); // 使用 Collections 类的 rotate() 来循环移动元素，方法第二个参数指定了移动的起始位置
System.out.println("rotate: " + rot);
// 查找 List 中的最大最小值
System.out.println("最大值: " + Collections.max(rot));
System.out.println("最小值: " + Collections.min(rot));
// 遍历 HashTable 的键值
Hashtable<String, String> ht = new Hashtable<String, String>();
ht.put("1", "One");
ht.put("2", "Two");
ht.put("3", "Three");
Enumeration<String> k = ht.keys(); // 使用 Hashtable 类的 keys() 方法来遍历输出键值
while (k.hasMoreElements()) {
System.out.println(k.nextElement());
}
// 使用 Enumeration 遍历 HashTable
Enumeration<String> e = ht.elements();
while (e.hasMoreElements()) {
System.out.println(e.nextElement());
}
// 集合中添加不同类型元素
addTest();
// List 元素替换
List<String> rep = Arrays.asList("one Two three Four five six one three Four".split(" "));
System.out.println("List :" + rep);
Collections.replaceAll(rep, "one", "hundrea");
System.out.println("replaceAll: " + rep);
// List 截取
List<String> sub = Arrays.asList("one Two three Four five six one three Four".split(" "));
System.out.println("List :" + sub);
List<String> sublist = Arrays.asList("three Four".split(" "));
System.out.println("子列表 :" + sublist);
System.out.println("indexOfSubList: " + Collections.indexOfSubList(sub, sublist));
System.out.println("lastIndexOfSubList: " + Collections.lastIndexOfSubList(sub, sublist));
}
private static void setTest() {
Set<String> set = new HashSet<String>();
set.add("JAVA");
set.add("C");
set.add("JAVA"); // 重复数据添加失败
set.add("PHP");
// 使用iterator遍历set集合
Iterator<String> it = set.iterator();
while (it.hasNext()) {
String value = it.next();
System.out.println(value);
}
// 使用增强for循环遍历set集合
for (String s : set) {
System.out.println(s);
}
}
// 遍历list集合
private static void listTest() {
List<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
// 使用iterator遍历
Iterator<String> it = list.iterator();
while (it.hasNext()) {
String value = it.next();
System.out.println(value);
}
// 使用传统for循环进行遍历
for (int i = 0, size = list.size(); i < size; i++) {
String value = list.get(i);
System.out.println(value);
}
// 使用增强for循环进行遍历
for (String value : list) {
System.out.println(value);
}
}
// 使用 Collection 和 Listiterator 类的 listIterator() 和 collection.reverse()
// 方法来反转集合中的元素
private static void revTest(String[] a) {
List<String> l = new ArrayList<String>();
for (int i = 0; i < a.length; i++) {
l.add(a[i]);
}
ListIterator<String> liter = l.listIterator();
System.out.println("反转前");
while (liter.hasNext())
System.out.println(liter.next());
Collections.reverse(l);
liter = l.listIterator();
System.out.println("反转后");
while (liter.hasNext())
System.out.println(liter.next());
}
// 使用 Collection 类的 collection.remove() 方法来删除集合中的指定的元素
private static void remTest() {
System.out.println("集合实例!\n");
int size;
HashSet<String> collection = new HashSet<String>();
String str1 = "Yellow", str2 = "White", str3 = "Green", str4 = "Blue";
Iterator<String> iterator;
collection.add(str1);
collection.add(str2);
collection.add(str3);
collection.add(str4);
System.out.print("集合数据: ");
iterator = collection.iterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + " ");
}
System.out.println();
collection.remove(str2);
System.out.println("删除之后 [" + str2 + "]\n");
System.out.print("现在集合的数据是: ");
iterator = collection.iterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + " ");
}
System.out.println();
size = collection.size();
System.out.println("集合大小: " + size + "\n");
}
// 使用 Collection 类的 Collections.unmodifiableList() 方法来设置集合为只读
private static void unmTest() {
List<String> stuff = Arrays.asList(new String[] { "a", "b" });
List<String> list = new ArrayList<String>(stuff);
list = Collections.unmodifiableList(list);
try {
list.set(0, "new value"); // 抛出异常，无法添加
} catch (UnsupportedOperationException e) {
e.printStackTrace();
}
Set<String> set = new HashSet<String>(stuff);
set = Collections.unmodifiableSet(set);
Map<?, ?> map = new HashMap<Object, Object>();
map = Collections.unmodifiableMap(map);
System.out.println("集合现在是只读");
}
// 使用 Java Util 类的 tMap.keySet(),tMap.values() 和 tMap.firstKey() 方法将集合元素输出
private static void outTest() {
System.out.println("TreeMap 实例！\n");
TreeMap<Integer, String> tMap = new TreeMap<Integer, String>();
tMap.put(1, "Sunday");
tMap.put(2, "Monday");
tMap.put(3, "Tuesday");
tMap.put(4, "Wednesday");
tMap.put(5, "Thursday");
tMap.put(6, "Friday");
tMap.put(7, "Saturday");
System.out.println("TreeMap 键：" + tMap.keySet());
System.out.println("TreeMap 值：" + tMap.values());
System.out.println("键为 5 的值为: " + tMap.get(5) + "\n");
System.out.println("第一个键: " + tMap.firstKey() + " Value: " + tMap.get(tMap.firstKey()) + "\n");
System.out.println("最后一个键: " + tMap.lastKey() + " Value: " + tMap.get(tMap.lastKey()) + "\n");
System.out.println("移除第一个数据: " + tMap.remove(tMap.firstKey()));
System.out.println("现在 TreeMap 键为: " + tMap.keySet());
System.out.println("现在 TreeMap 包含: " + tMap.values() + "\n");
System.out.println("移除最后一个数据: " + tMap.remove(tMap.lastKey()));
System.out.println("现在 TreeMap 键为: " + tMap.keySet());
System.out.println("现在 TreeMap 包含: " + tMap.values());
}
private static void addTest() {
List<String> lnkLst = new LinkedList<String>();
lnkLst.add("element1");
lnkLst.add("element2");
lnkLst.add("element3");
displayAll(lnkLst);
List<String> aryLst = new ArrayList<String>();
aryLst.add("x");
aryLst.add("y");
aryLst.add("z");
displayAll(aryLst);
Set<String> hashSet = new HashSet<String>();
hashSet.add("set1");
hashSet.add("set2");
hashSet.add("set3");
displayAll(hashSet);
SortedSet<String> treeSet = new TreeSet<String>();
treeSet.add("1");
treeSet.add("2");
treeSet.add("3");
displayAll(treeSet);
LinkedHashSet<String> lnkHashset = new LinkedHashSet<String>();
lnkHashset.add("one");
lnkHashset.add("two");
lnkHashset.add("three");
displayAll(lnkHashset);
Map<String, String> map1 = new HashMap<String, String>();
map1.put("key1", "J");
map1.put("key2", "K");
map1.put("key3", "L");
displayAll(map1.keySet());
displayAll(map1.values());
SortedMap<String, String> map2 = new TreeMap<String, String>();
map2.put("key1", "JJ");
map2.put("key2", "KK");
map2.put("key3", "LL");
displayAll(map2.keySet());
displayAll(map2.values());
LinkedHashMap<String, String> map3 = new LinkedHashMap<String, String>();
map3.put("key1", "JJJ");
map3.put("key2", "KKK");
map3.put("key3", "LLL");
displayAll(map3.keySet());
displayAll(map3.values());
}
private static void displayAll(Collection<String> col) {
Iterator<String> itr = col.iterator();
while (itr.hasNext()) {
String str = (String) itr.next();
System.out.print(str + " ");
}
System.out.println();
}
}
扫一扫
336
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
