BeginnersBook Java 集合教程（一）
如何在 Java 中对ArrayList进行排序
原文： https://beginnersbook.com/2013/12/how-to-sort-arraylist-in-java/
在本教程中，我们分享了对ArrayList<String>和ArrayList<Integer>进行排序的示例。
另请阅读：
示例 1：ArrayList<String>的排序
这里我们正在对String类型的ArrayList进行排序。我们只需调用Collections.sort(arraylist)方法即可。输出列表将按字母顺序排序。
import java.util.*;
public class Details {
public static void main(String args[]){
ArrayList<String> listofcountries = new ArrayList<String>();
listofcountries.add("India");
listofcountries.add("US");
listofcountries.add("China");
listofcountries.add("Denmark");
/*Unsorted List*/
System.out.println("Before Sorting:");
for(String counter: listofcountries){
System.out.println(counter);
}
/* Sort statement*/
Collections.sort(listofcountries);
/* Sorted List*/
System.out.println("After Sorting:");
for(String counter: listofcountries){
System.out.println(counter);
}
}
}
输出：
Before Sorting:
India
US
China
Denmark
After Sorting:
China
Denmark
India
US
示例 2：ArrayList<Integer>的排序
相同的Collections.sort()方法也可用于对整数ArrayList进行排序。
import java.util.*;
public class ArrayListOfInteger {
public static void main(String args[]){
ArrayList<Integer> arraylist = new ArrayList<Integer>();
arraylist.add(11);
arraylist.add(2);
arraylist.add(7);
arraylist.add(3);
/* ArrayList before the sorting*/
System.out.println("Before Sorting:");
for(int counter: arraylist){
System.out.println(counter);
}
/* Sorting of arraylist using Collections.sort*/
Collections.sort(arraylist);
/* ArrayList after sorting*/
System.out.println("After Sorting:");
for(int counter: arraylist){
System.out.println(counter);
}
}
}
输出：
Before Sorting:
11
2
7
3
After Sorting:
2
3
7
11
Java - 将Vector转换为ArrayList
原文： https://beginnersbook.com/2014/07/java-convert-vector-to-arraylist-example/
在上一个教程中，我们分享了如何将Vector转换为数组。在这里，我们将通过示例看到Vector到ArrayList转换。
示例
在下面的代码片段中，我们有一个字符串的Vector，我们将其转换为字符串的ArrayList 。我们在下面的示例中遵循的步骤是：
1）创建一个Vector并填充它（我们假设Vector将具有String元素）。
2）通过使用Vector对象声明ArrayList对象，将Vector转换为ArrayList。
ArrayList list = new ArrayList(vector);
代码：
import java.util.Vector;
import java.util.ArrayList;
public class VectorToArrayList {
public static void main(String[] args) {
// Creating a Vector of String elements
Vector<String> vector = new Vector<String>();
// Populate Vector
vector.add("Rahul");
vector.add("Steve");
vector.add("Jude");
vector.add("Locke");
vector.add("Mike");
vector.add("Robert");
//Displaying Vector elements
for (String str : vector){
System.out.println(str);
}
//Converting Vector to ArrayList
ArrayList<String> arraylist = new ArrayList<String>(vector);
//Displaying ArrayList Elements
System.out.println("\nArrayList Elements :");
for (String s : arraylist){
System.out.println(s);
}
}
}
输出：
Rahul
Steve
Jude
Locke
Mike
Robert
ArrayList Elements :
Rahul
Steve
Jude
Locke
Mike
Robert
如何在 java 中将Vector转换为字符串数组
原文： https://beginnersbook.com/2014/07/how-to-convert-vector-to-string-array-in-java/
几个星期前我们分享了ArrayList到String数组的转换的教程。在本教程中，我们将了解如何在 Java 中将Vector转换为String数组。
示例
让我们看一下下面的例子，我们将一个字符串Vector转换为一个数组。我们使用Vector类的toString()方法来做到这一点。
public String toString()：返回此Vector的字符串表示形式，包含每个元素的String表示形式。
import java.util.Vector;
public class VectorToArray {
public static void main(String[] args) {
// Creating a Vector of String elements
Vector<String> vector = new Vector<String>();
// Add elements to Vector
vector.add("Item1");
vector.add("Item2");
vector.add("Item3");
vector.add("Item4");
vector.add("Item5");
vector.add("Item6");
//Converting Vector to String Array
String[] array = vector.toArray(new String[vector.size()]);
//Displaying Array Elements
System.out.println("String Array Elements :");
for(int i=0; i < array.length ; i++){
System.out.println(array[i]);
}
}
}
输出：
String Array Elements :
Item1
Item2
Item3
Item4
Item5
Item6
我们在上面的代码中遵循的步骤是：
1）创建一个String类型的向量
2）使用Vector类的add(Element E)方法向其添加元素。
3）使用toArray(new String[vector.size()])将Vector转换为数组。
Java 集合 - Set
HashSet
Java 中的HashSet类
原文： https://beginnersbook.com/2013/12/hashset-class-in-java-with-example/
此类实现Set接口，由哈希表（实际上是HashMap实例）支持。它不能保证集合的迭代顺序;特别是，它不保证订单会随着时间的推移保持不变。该类允许null元素。此类未同步。但是它可以像这样明确地同步：Set s = Collections.synchronizedSet(new HashSet(...));
关于HashSet的注意事项：
HashSet不维护任何顺序，元素将以任何随机顺序返回。HashSet不允许重复。如果您尝试在 HashSet 中添加重复元素，则旧值将被覆盖。HashSet允许空值，但是如果插入多个空值，它仍然只返回一个空值。HashSet是非同步的。- 这个类返回的迭代器是快速失败的，这意味着如果在创建迭代器之后修改了
HashSet，迭代器会抛出ConcurrentModificationException，除了迭代器自己的remove方法之外。
HashSet示例
import java.util.HashSet;
public class HashSetExample {
public static void main(String args[]) {
// HashSet declaration
HashSet<String> hset =
new HashSet<String>();
// Adding elements to the HashSet
hset.add("Apple");
hset.add("Mango");
hset.add("Grapes");
hset.add("Orange");
hset.add("Fig");
//Addition of duplicate elements
hset.add("Apple");
hset.add("Mango");
//Addition of null values
hset.add(null);
hset.add(null);
//Displaying HashSet elements
System.out.println(hset);
}
}
输出：
[null, Mango, Grapes, Apple, Orange, Fig]
如您所见，输出中不存在所有重复值，包括重复的空值。
HashSet教程
- 删除
HashSet中的所有元素 - 如何遍历
HashSet - 将
HashSet转换为数组 - 将
HashSet转换为TreeSet - 将
HashSet转换为List/ArrayList HashSetvsHashMapHashSetvsTreeSet
HashSet方法：
boolean add(Element e)：它将元素 e 添加到列表中。void clear()：它从列表中删除所有元素。Object clone()：此方法返回HashSet的浅表副本。boolean contains(Object o)：它检查指定的Object o是否存在于列表中。如果找到该对象，则返回true，否则返回false。boolean isEmpty()：如果Set中没有元素，则返回true。int size()：它给出了一个Set的元素个数。boolean(Object o)：它从Set中删除指定的Object o。
参考
从HashSet中删除所有元素
原文： https://beginnersbook.com/2014/08/delete-all-the-elements-from-hashset/
在这里，我们将看到如何一次性删除HashSet的所有元素。我们可以通过调用HashSet类的clear()方法来实现。
示例
import java.util.HashSet;
class EmptyHashSetExample{
public static void main(String[] args) {
// Create a HashSet
HashSet<String> hset = new HashSet<String>();
//add elements to HashSet
hset.add("Element1");
hset.add("Element2");
hset.add("Element3");
hset.add("Element4");
hset.add("Element5");
// Display HashSet elements
System.out.println("Before: HashSet contains: "+ hset);
/* public void clear(): It removes all the elements
* from HashSet. The set becomes empty after this
* method gets called.
*/
hset.clear();
// Display HashSet content again
System.out.println("After: HashSet contains: "+ hset);
}
}
输出：
Before: HashSet contains: [Element1, Element2, Element3, Element4, Element5]
After: HashSet contains: []
如何迭代Set/HashSet
原文： https://beginnersbook.com/2014/08/how-to-iterate-over-a-sethashset/
迭代HashSet有两种方法：
1）使用Iterator
2）不使用Iterator
示例 1：使用迭代器
import java.util.HashSet;
import java.util.Iterator;
class IterateHashSet{
public static void main(String[] args) {
// Create a HashSet
HashSet<String> hset = new HashSet<String>();
//add elements to HashSet
hset.add("Chaitanya");
hset.add("Rahul");
hset.add("Tim");
hset.add("Rick");
hset.add("Harry");
Iterator<String> it = hset.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
输出：
Chaitanya
Rick
Harry
Rahul
Tim
示例 2：不使用迭代器迭代
import java.util.HashSet;
import java.util.Set;
class IterateHashSet{
public static void main(String[] args) {
// Create a HashSet
Set<String> hset = new HashSet<String>();
//add elements to HashSet
hset.add("Chaitanya");
hset.add("Rahul");
hset.add("Tim");
hset.add("Rick");
hset.add("Harry");
for (String temp : hset) {
System.out.println(temp);
}
}
}
输出：
Chaitanya
Rick
Harry
Rahul
Tim
将HashSet转换为数组
原文： https://beginnersbook.com/2014/08/converting-a-hashset-to-an-array/
这是将HashSet转换为数组的程序。
程序
import java.util.HashSet;
class ConvertHashSettoArray{
public static void main(String[] args) {
// Create a HashSet
HashSet<String> hset = new HashSet<String>();
//add elements to HashSet
hset.add("Element1");
hset.add("Element2");
hset.add("Element3");
hset.add("Element4");
// Displaying HashSet elements
System.out.println("HashSet contains: "+ hset);
// Creating an Array
String[] array = new String[hset.size()];
hset.toArray(array);
// Displaying Array elements
System.out.println("Array elements: ");
for(String temp : array){
System.out.println(temp);
}
}
}
输出：
HashSet contains: [Element1, Element2, Element3, Element4]
Array elements:
Element1
Element2
Element3
Element4
如何将HashSet转换为TreeSet
原文： https://beginnersbook.com/2014/08/how-to-convert-a-hashset-to-a-treeset/
描述
将HashSet转换为TreeSet的程序
程序
这是HashSet到TreeSet转换的完整代码。我们有一个HashSet<String>，我们通过将HashSet的所有元素复制到TreeSet来创建字符串TreeSet。
import java.util.HashSet;
import java.util.TreeSet;
import java.util.Set;
class ConvertHashSettoTreeSet{
public static void main(String[] args) {
// Create a HashSet
HashSet<String> hset = new HashSet<String>();
//add elements to HashSet
hset.add("Element1");
hset.add("Element2");
hset.add("Element3");
hset.add("Element4");
// Displaying HashSet elements
System.out.println("HashSet contains: "+ hset);
// Creating a TreeSet of HashSet elements
Set<String> tset = new TreeSet<String>(hset);
// Displaying TreeSet elements
System.out.println("TreeSet contains: ");
for(String temp : tset){
System.out.println(temp);
}
}
}
输出：
HashSet contains: [Element1, Element2, Element3, Element4]
TreeSet contains:
Element1
Element2
Element3
Element4
将HashSet转换为List / ArrayList
原文： https://beginnersbook.com/2014/08/convert-hashset-to-a-list-arraylist/
在本教程中，我们将学习如何将HashSet转换为List（ArrayList）。
程序
这里我们有一个String元素的HashSet，我们通过将HashSet的所有元素复制到ArrayList来创建一个String的ArrayList。以下是完整的代码：
import java.util.HashSet;
import java.util.List;
import java.util.ArrayList;
class ConvertHashSetToArrayList{
public static void main(String[] args) {
// Create a HashSet
HashSet<String> hset = new HashSet<String>();
//add elements to HashSet
hset.add("Steve");
hset.add("Matt");
hset.add("Govinda");
hset.add("John");
hset.add("Tommy");
// Displaying HashSet elements
System.out.println("HashSet contains: "+ hset);
// Creating a List of HashSet elements
List<String> list = new ArrayList<String>(hset);
// Displaying ArrayList elements
System.out.println("ArrayList contains: "+ list);
}
}
输出：
HashSet contains: [Tommy, Matt, Steve, Govinda, John]
ArrayList contains: [Tommy, Matt, Steve, Govinda, John]
如何在 Java 中按降序对ArrayList进行排序
原文： https://beginnersbook.com/2013/12/sort-arraylist-in-descending-order-in-java/
之前我们分享了ArrayList升序排序的例子。在这里，我们将学习如何按降序（或递减顺序）对ArrayList进行排序。
示例：按降序排序
我们使用Collections.reverseOrder()方法和Collections.sort()以按降序对列表进行排序。在下面的示例中，我们使用以下语句以相反的顺序进行排序。
Collections.sort(arraylist, Collections.reverseOrder());
但是，逆序排序也可以如下进行 - 这样列表将首先按升序排序，然后反转。
Collections.sort(list);
Collections.reverse(list);
完整的例子：
import java.util.*;
public class Details {
public static void main(String args[]){
ArrayList<String> arraylist = new ArrayList<String>();
arraylist.add("AA");
arraylist.add("ZZ");
arraylist.add("CC");
arraylist.add("FF");
/*Unsorted List: ArrayList content before sorting*/
System.out.println("Before Sorting:");
for(String str: arraylist){
System.out.println(str);
}
/* Sorting in decreasing order*/
Collections.sort(arraylist, Collections.reverseOrder());
/* Sorted List in reverse order*/
System.out.println("ArrayList in descending order:");
for(String str: arraylist){
System.out.println(str);
}
}
}
输出：
Before Sorting:
AA
ZZ
CC
FF
ArrayList in descending order:
ZZ
FF
CC
AA
在上面的例子中，我们使用 String 类型的ArrayList（ArrayList<String>）进行排序。同样的排序方法也可以用于整数列表。
HashSet和HashMap之间的区别
原文： https://beginnersbook.com/2014/08/hashset-vs-hashmap-java/
在本文中，我们将讨论HashSet和HashMap类之间的差异。
HashSet vs HashMap
差异：
HashSet |
HashMap |
|---|---|
HashSet类实现Set接口 |
HashMap类实现了Map接口 |
在HashSet中，我们存储对象（元素或值），例如如果我们有一个字符串元素的HashSet，那么它可以描述一组HashSet元素：{"Hello", "Hi", "Bye", "Run"} |
HashMap用于存储键值对。简而言之，它保持了键和键的映射。（HashMap类大致相当于Hashtable，除了它是不同步的并且允许空值。）如果HashMap元素具有整数键和String类型的值，则可以表示HashMap元素：{1->"Hello", 2->"Hi", 3->"Bye", 4->"Run"} |
HashSet不允许重复元素，这意味着您无法在HashSet中存储重复值。 |
HashMap不允许重复键，但它允许重复值。 |
HashSet允许具有单个空值。 |
HashMap允许单个null键和任意数量的空值。 |
相似之处：
1）HashMap和HashSet都不同步，这意味着它们不适合线程安全操作unitl，除非明确同步。这是你可以明确地同步它们的方法：
HashSet：
Set s = Collections.synchronizedSet(new HashSet(...));
HashMap：
Map m = Collections.synchronizedMap(new HashMap(...));
2）这两个类都不保证其元素的顺序会随着时间的推移保持不变。
3）如果查看HashSet的源代码，您可能会发现它由HashMap备份。所以基本上它在内部使用HashMap进行所有操作。
4）它们都为基本操作提供恒定的时间性能，例如添加，删除元素等。
HashSet示例
import java.util.HashSet;
class HashSetDemo{
public static void main(String[] args) {
// Create a HashSet
HashSet<String> hset = new HashSet<String>();
//add elements to HashSet
hset.add("AA");
hset.add("BB");
hset.add("CC");
hset.add("DD");
// Displaying HashSet elements
System.out.println("HashSet contains: ");
for(String temp : hset){
System.out.println(temp);
}
}
}
输出：
HashSet contains:
AA
BB
CC
DD
HashMap示例
import java.util.HashMap;
class HashMapDemo{
public static void main(String[] args) {
// Create a HashMap
HashMap<Integer, String> hmap = new HashMap<Integer, String>();
//add elements to HashMap
hmap.put(1, "AA");
hmap.put(2, "BB");
hmap.put(3, "CC");
hmap.put(4, "DD");
// Displaying HashMap elements
System.out.println("HashMap contains: "+hmap);
}
}
输出：
HashMap contains: {1=AA, 2=BB, 3=CC, 4=DD}
参考：
HashSet javadoc
HashMap javadoc
LinkedHashSet
Java 中的LinkedHashSet类
原文： https://beginnersbook.com/2013/12/linkedhashset-class-in-java-with-example/
之前我们已经在HashSet和TreeSet上分享了教程。LinkedHashSet也是Set接口的一个实现，它类似于HashSet和TreeSet，除了下面提到的差异：
HashSet不保持其元素的任何顺序。TreeSet按升序对元素进行排序。LinkedHashSet保持插入顺序。元素按照添加到Set中的相同顺序进行排序。
LinkedHashSet的示例：
import java.util.LinkedHashSet;
public class LinkedHashSetExample {
public static void main(String args[]) {
// LinkedHashSet of String Type
LinkedHashSet<String> lhset = new LinkedHashSet<String>();
// Adding elements to the LinkedHashSet
lhset.add("Z");
lhset.add("PQ");
lhset.add("N");
lhset.add("O");
lhset.add("KK");
lhset.add("FGH");
System.out.println(lhset);
// LinkedHashSet of Integer Type
LinkedHashSet<Integer> lhset2 = new LinkedHashSet<Integer>();
// Adding elements
lhset2.add(99);
lhset2.add(7);
lhset2.add(0);
lhset2.add(67);
lhset2.add(89);
lhset2.add(66);
System.out.println(lhset2);
}
}
输出：
[Z, PQ, N, O, KK, FGH]
[99, 7, 0, 67, 89, 66]
观察输出：两种类型的LinkedHashSet都保留了插入顺序。
Java 中List和Set之间的区别
原文： https://beginnersbook.com/2014/07/difference-between-list-and-set-in-java/
List和Set都是接口。它们都扩展了Collection接口。在这篇文章中，我们讨论了 java 中List和Set接口之间的差异。
List Vs Set
1）List是一个有序集合，它维护插入顺序，这意味着在显示列表内容时，它将按照它们插入列表的顺序显示元素。
Set是一个无序集合，它不保持任何顺序。 维护顺序的Set很少，例如LinkedHashSet（它按插入顺序维护元素）。
2）List允许重复，而Set不允许重复元素。如果您尝试将重复元素插入Set中，它将替换现有值，则Set的所有元素都应该是唯一的。
3）List实现： ArrayList ， LinkedList等。
Set实现： HashSet， LinkedHashSet， TreeSet 等。
4）List允许任意数量的空值。 Set最多只能有一个空值。
5） ListIterator可用于在两个方向（前向和后向）遍历List但是它不能用于遍历Se。我们可以使用迭代器（它也适用于List）来遍历一个Set。
6）List接口有一个名为Vector 的遗留类，而Set接口没有任何遗留类。
何时使用Set和何时使用List？
用法完全取决于要求：
如果要求只有唯一值，那么Set是您最好的选择，因为Set的任何实现仅维护唯一值。
如果需要维持插入顺序而不管双重性，则List是最佳选择。List接口的实现 - ArrayList和LinkedList按其插入顺序对元素进行排序。
列表示例
import java.util.List;
import java.util.ArrayList;
import java.util.LinkedList;
public class ListExample {
public static void main(String[] args) {
List<String> al = new ArrayList<String>();
al.add("Chaitanya");
al.add("Rahul");
al.add("Ajeet");
System.out.println("ArrayList Elements: ");
System.out.print(al);
List<String> ll = new LinkedList<String>();
ll.add("Kevin");
ll.add("Peter");
ll.add("Kate");
System.out.println("\nLinkedList Elements: ");
System.out.print(ll);
}
}
输出：
ArrayList Elements:
[Chaitanya, Rahul, Ajeet]
LinkedList Elements:
[Kevin, Peter, Kate]
设置示例
import java.util.Set;
import java.util.HashSet;
import java.util.TreeSet;
public class SetExample {
public static void main(String args[]) {
int count[] = {11, 22, 33, 44, 55};
Set<Integer> hset = new HashSet<Integer>();
try{
for(int i = 0; i<4; i++){
hset.add(count[i]);
}
System.out.println(hset);
TreeSet<Integer> treeset = new TreeSet<Integer>(hset);
System.out.println("The sorted list is:");
System.out.println(treeset);
}
catch(Exception e){
e.printStackTrace();
}
}
}
输出：
[33, 22, 11, 44]
The sorted list is:
[11, 22, 33, 44]
TreeSet
Java 中的TreeSet类
原文： https://beginnersbook.com/2013/12/treeset-class-in-java-with-example/
TreeSet类似于HashSet，不同之处在于它按升序对元素进行排序，而HashSet不维护任何顺序。TreeSet允许null元素，但它不允许使用HashSet。像大多数其他集合类一样，这个类也没有同步，但它可以像这样明确地同步： SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...));
在本教程中，我们将看到TreeSet示例以及TreeSet和其他类似集合类之间的区别。
TreeSet 示例：
在这个例子中，我们有两个TreeSet（TreeSet<String>和TreeSet<Integer>）。我们已经随机地将值添加到它们中，但是我们得到的结果按升序排序。
import java.util.TreeSet;
public class TreeSetExample {
public static void main(String args[]) {
// TreeSet of String Type
TreeSet<String> tset = new TreeSet<String>();
// Adding elements to TreeSet<String>
tset.add("ABC");
tset.add("String");
tset.add("Test");
tset.add("Pen");
tset.add("Ink");
tset.add("Jack");
//Displaying TreeSet
System.out.println(tset);
// TreeSet of Integer Type
TreeSet<Integer> tset2 = new TreeSet<Integer>();
// Adding elements to TreeSet<Integer>
tset2.add(88);
tset2.add(7);
tset2.add(101);
tset2.add(0);
tset2.add(3);
tset2.add(222);
System.out.println(tset2);
}
}
输出：您可以看到TreeSet已按隐式升序排序。
[ABC, Ink, Jack, Pen, String, Test]
[0, 3, 7, 88, 101, 222]
TreeSet教程
参考
HashSet和TreeSet之间的区别
原文： https://beginnersbook.com/2014/08/difference-between-hashset-and-treeset/
在本文中，我们将讨论HashSet和TreeSet之间的差异。
HashSet与TreeSet
1） HashSet比TreeSet为add，remove，contains，size等操作提供更好的性能（更快）。HashSet提供恒定的时间成本，而对于这样的操作TreeSet提供log(n)时间成本。
2）HashSet不维护任何元素顺序，而TreeSet元素默认按升序排序。
相似之处：
1）HashSet和TreeSet都不包含重复元素，这意味着它们都是重复的。
2）如果你想要一个有序的Set，那么最好将元素添加到HashSet然后将其转换为TreeSet ，而不是创建一个TreeSet并向其添加元素。
3）这两个类都是非同步的，这意味着它们不是线程安全的，并且在需要线程安全操作时应该显式同步。
例子：
HashSet示例
import java.util.HashSet;
class HashSetDemo{
public static void main(String[] args) {
// Create a HashSet
HashSet<String> hset = new HashSet<String>();
//add elements to HashSet
hset.add("Abhijeet");
hset.add("Ram");
hset.add("Kevin");
hset.add("Singh");
hset.add("Rick");
// Duplicate removed
hset.add("Ram");
// Displaying HashSet elements
System.out.println("HashSet contains: ");
for(String temp : hset){
System.out.println(temp);
}
}
}
输出：
HashSet contains:
Rick
Singh
Ram
Kevin
Abhijeet
TreeSet示例
import java.util.TreeSet;
class TreeSetDemo{
public static void main(String[] args) {
// Create a TreeSet
TreeSet<String> tset = new TreeSet<String>();
//add elements to TreeSet
tset.add("Abhijeet");
tset.add("Ram");
tset.add("Kevin");
tset.add("Singh");
tset.add("Rick");
// Duplicate removed
tset.add("Ram");
// Displaying TreeSet elements
System.out.println("TreeSet contains: ");
for(String temp : tset){
System.out.println(temp);
}
}
}
输出：元素按升序排序。
TreeSet contains:
Abhijeet
Kevin
Ram
Rick
Singh
Java 集合 - Map
HashMap
HashMap基础知识
Java ArrayList对象排序（Comparable和Comparator）
原文： https://beginnersbook.com/2013/12/java-arraylist-of-object-sort-example-comparable-and-comparator/
在本教程中，我们将看到如何使用可比较对象和比较器接口按属性对对象的ArrayList进行排序。如果您正在寻找对String或Integer的简单ArrayList进行排序，那么您可以参考以下教程 -
我们通常使用Collections.sort()方法对一个简单的ArrayList进行排序。但是，如果ArrayList是自定义对象类型，那么在这种情况下，您有两个选项可用于排序 - 可比较和比较器接口。在介绍它们的示例之前，让我们看看当我们尝试对对象的arraylist进行排序而不实现任何这些接口时的输出是什么。
为什么需要Comparable和Comparator？
考虑下面的例子 - 我有一个 Student 类，它具有学生姓名，掷骰号和学生年龄等属性。
public class Student {
private String studentname;
private int rollno;
private int studentage;
public Student(int rollno, String studentname, int studentage) {
this.rollno = rollno;
this.studentname = studentname;
this.studentage = studentage;
}
public String getStudentname() {
return studentname;
}
public void setStudentname(String studentname) {
this.studentname = studentname;
}
public int getRollno() {
return rollno;
}
public void setRollno(int rollno) {
this.rollno = rollno;
}
public int getStudentage() {
return studentage;
}
public void setStudentage(int studentage) {
this.studentage = studentage;
}
}
我想要一个学生对象的ArrayList。我们这样做 -
import java.util.*;
public class ArrayListSorting {
public static void main(String args[]){
ArrayList<Student> arraylist = new ArrayList<Student>();
arraylist.add(new Student(223, "Chaitanya", 26));
arraylist.add(new Student(245, "Rahul", 24));
arraylist.add(new Student(209, "Ajeet", 32));
Collections.sort(arraylist);
for(Student str: arraylist){
System.out.println(str);
}
}
}
我试图在对象列表上调用Collections.sort()并繁荣！我得到了这样的错误信息 -
线程main中的异常java.lang.Error：未解决的编译问题：
Bound mismatch: The generic method sort(List) of type Collections is not applicable for the arguments (ArrayList). The inferred type Student is not a valid substitute for the bounded parameter > at beginnersbook.com.Details.main(Details.java:11)
原因：我刚刚在对象的ArrayList上调用了sort方法，除非我们使用Comparable和Comparator之类的接口，否则它实际上不起作用。
现在您必须了解这些接口的重要性。让我们看看如何使用它们以我们的方式完成排序。
使用Comparable排序ArrayList<Object>
假设我们需要对ArrayList<Student>进行排序。根据学生年龄属性。这是如何做到的 - 首先实现Comparable接口，然后覆盖compareTo方法。
package beginnersbook.com;
public class Student implements Comparable {
private String studentname;
private int rollno;
private int studentage;
public Student(int rollno, String studentname, int studentage) {
this.rollno = rollno;
this.studentname = studentname;
this.studentage = studentage;
}
...
//getter and setter methods same as the above example
...
@Override
public int compareTo(Student comparestu) {
int compareage=((Student)comparestu).getStudentage();
/* For Ascending order*/
return this.studentage-compareage;
/* For Descending order do like this */
//return compareage-this.studentage;
}
@Override
public String toString() {
return "[ rollno=" + rollno + ", name=" + studentname + ", age=" + studentage + "]";
}
}
现在我们可以在ArrayList上调用Collections.sort
import java.util.*;
public class ArrayListSorting {
public static void main(String args[]){
ArrayList<Student> arraylist = new ArrayList<Student>();
arraylist.add(new Student(223, "Chaitanya", 26));
arraylist.add(new Student(245, "Rahul", 24));
arraylist.add(new Student(209, "Ajeet", 32));
Collections.sort(arraylist);
for(Student str: arraylist){
System.out.println(str);
}
}
}
输出：
[ rollno=245, name=Rahul, age=24]
[ rollno=223, name=Chaitanya, age=26]
[ rollno=209, name=Ajeet, age=32]
Comparable做了我们的工作为什么我们需要Comparator了？
由于Comparable是由对象进行排序的同一个类实现的，所以它会绑定你的排序逻辑，在大多数情况下都可以，但是如果你想要的方法不仅仅是对类对象进行排序了应该使用比较器。在这里阅读更多相关信息：
使用Comparator的多个属性对ArrayList<Object>进行排序
我们优先使用Comparator的[compare](https://docs.oracle.com/javase/6/docs/api/java/util/Comparator.html#compare(T, T))方法进行排序。
package beginnersbook.com;
import java.util.Comparator;
public class Student {
private String studentname;
private int rollno;
private int studentage;
public Student(int rollno, String studentname, int studentage) {
this.rollno = rollno;
this.studentname = studentname;
this.studentage = studentage;
}
...
//Getter and setter methods same as the above examples
...
/*Comparator for sorting the list by Student Name*/
public static Comparator<Student> StuNameComparator = new Comparator<Student>() {
public int compare(Student s1, Student s2) {
String StudentName1 = s1.getStudentname().toUpperCase();
String StudentName2 = s2.getStudentname().toUpperCase();
//ascending order
return StudentName1.compareTo(StudentName2);
//descending order
//return StudentName2.compareTo(StudentName1);
}};
/*Comparator for sorting the list by roll no*/
public static Comparator<Student> StuRollno = new Comparator<Student>() {
public int compare(Student s1, Student s2) {
int rollno1 = s1.getRollno();
int rollno2 = s2.getRollno();
/*For ascending order*/
return rollno1-rollno2;
/*For descending order*/
//rollno2-rollno1;
}};
@Override
public String toString() {
return "[ rollno=" + rollno + ", name=" + studentname + ", age=" + studentage + "]";
}
}
ArrayList类：
package beginnersbook.com;
import java.util.*;
public class Details {
public static void main(String args[]){
ArrayList<Student> arraylist = new ArrayList<Student>();
arraylist.add(new Student(101, "Zues", 26));
arraylist.add(new Student(505, "Abey", 24));
arraylist.add(new Student(809, "Vignesh", 32));
/*Sorting based on Student Name*/
System.out.println("Student Name Sorting:");
Collections.sort(arraylist, Student.StuNameComparator);
for(Student str: arraylist){
System.out.println(str);
}
/* Sorting on Rollno property*/
System.out.println("RollNum Sorting:");
Collections.sort(arraylist, Student.StuRollno);
for(Student str: arraylist){
System.out.println(str);
}
}
}
输出：
Student Name Sorting:
[ rollno=505, name=Abey, age=24]
[ rollno=809, name=Vignesh, age=32]
[ rollno=101, name=Zues, age=26]
RollNum Sorting:
[ rollno=101, name=Zues, age=26]
[ rollno=505, name=Abey, age=24]
[ rollno=809, name=Vignesh, age=32]
Java 中的HashMap
原文： https://beginnersbook.com/2013/12/hashmap-in-java-with-example/
HashMap是一个基于Map的集合类，用于存储键值对，表示为HashMap<Key, Value>或HashMap<K, V>。此类不保证映射的顺序。它类似于Hashtable类，除了它是不同步的并且允许空值（空值和空键）。
它不是有序集合，这意味着它不会按照它们插入HashMap的顺序返回键和值。它不会对存储的键和值进行排序。您必须导入java.util.HashMap或其超类才能使用HashMap类和方法。
Java 中的HashMap示例：
在这个例子中，我们已经演示了几乎所有HashMap类的重要方法。
import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
import java.util.Set;
public class Details {
public static void main(String args[]) {
/* This is how to declare HashMap */
HashMap<Integer, String> hmap = new HashMap<Integer, String>();
/*Adding elements to HashMap*/
hmap.put(12, "Chaitanya");
hmap.put(2, "Rahul");
hmap.put(7, "Singh");
hmap.put(49, "Ajeet");
hmap.put(3, "Anuj");
/* Display content using Iterator*/
Set set = hmap.entrySet();
Iterator iterator = set.iterator();
while(iterator.hasNext()) {
Map.Entry mentry = (Map.Entry)iterator.next();
System.out.print("key is: "+ mentry.getKey() + " & Value is: ");
System.out.println(mentry.getValue());
}
/* Get values based on key*/
String var= hmap.get(2);
System.out.println("Value at index 2 is: "+var);
/* Remove values based on key*/
hmap.remove(3);
System.out.println("Map key and values after removal:");
Set set2 = hmap.entrySet();
Iterator iterator2 = set2.iterator();
while(iterator2.hasNext()) {
Map.Entry mentry2 = (Map.Entry)iterator2.next();
System.out.print("Key is: "+mentry2.getKey() + " & Value is: ");
System.out.println(mentry2.getValue());
}
}
}
输出：
key is: 49 & Value is: Ajeet
key is: 2 & Value is: Rahul
key is: 3 & Value is: Anuj
key is: 7 & Value is: Singh
key is: 12 & Value is: Chaitanya
Value at index 2 is: Rahul
Map key and values after removal:
Key is: 49 & Value is: Ajeet
Key is: 2 & Value is: Rahul
Key is: 7 & Value is: Singh
Key is: 12 & Value is: Chaitanya
HashMap类方法
以下是HashMap类中可用的方法列表。我还在本文末尾介绍了使用这些方法的示例。
void clear()：它从指定的Map中删除所有键和值对。Object clone()：它返回映射所有映射的副本，用于将它们克隆到另一个映射中。boolean containsKey(Object key)：它是一个布尔函数，它根据是否在映射中找到指定的键返回true或false。boolean containsValue(Object Value)：与containsKey()方法类似，但它查找指定的值而不是key。Value get(Object key)：返回指定键的值。boolean isEmpty()：它检查映射是否为空。如果映射中没有键值映射，则此函数返回true，否则返回false。Set keySet()：返回从映射中获取的键的Set。Value put(Key k, Value v)：将键值映射插入到映射中。用于上面的例子。int size()：返回映射的大小 - 键值映射的数量。Set values()：返回映射的值集合。Value remove(Object key)：删除指定键的键值对。用于上面的例子。void putAll(Map m)：将映射的所有元素复制到另一个指定的映射。
HashMap教程
以下是在HashMap类上发布的教程列表。学习快乐！
HashMap基础知识
获取/搜索
序列化/同步
差异
其他教程
参考：
如何在 java 中循环HashMap
原文： https://beginnersbook.com/2013/12/how-to-loop-hashmap-in-java/
在本教程中，我们将学习如何使用以下方法循环HashMap：
for循环while循环 + 迭代器
示例：
在下面的示例中，我们使用两种方法（for循环和while循环）迭代HashMap。在while循环中，我们使用了迭代器。
package beginnersbook.com;
import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
public class Details
{
public static void main(String [] args)
{
HashMap<Integer, String> hmap = new HashMap<Integer, String>();
//Adding elements to HashMap
hmap.put(11, "AB");
hmap.put(2, "CD");
hmap.put(33, "EF");
hmap.put(9, "GH");
hmap.put(3, "IJ");
//FOR LOOP
System.out.println("For Loop:");
for (Map.Entry me : hmap.entrySet()) {
System.out.println("Key: "+me.getKey() + " & Value: " + me.getValue());
}
//WHILE LOOP & ITERATOR
System.out.println("While Loop:");
Iterator iterator = hmap.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry me2 = (Map.Entry) iterator.next();
System.out.println("Key: "+me2.getKey() + " & Value: " + me2.getValue());
}
}
}
输出：
For Loop:
Key: 2 & Value: CD
Key: 3 & Value: IJ
Key: 33 & Value: EF
Key: 9 & Value: GH
Key: 11 & Value: AB
While Loop:
Key: 2 & Value: CD
Key: 3 & Value: IJ
Key: 33 & Value: EF
Key: 9 & Value: GH
Key: 11 & Value: AB
参考：
如何按键和值对 Java 中的HashMap进行排序
原文： https://beginnersbook.com/2013/12/how-to-sort-hashmap-in-java-by-keys-and-values/
我们知道HashMap默认不保留任何顺序。如果有需要，我们需要根据需求明确排序。在本教程中，我们将学习如何对TreeMap使用Comparator按键和按值进行排序。
HashMap按键排序
在这个例子中，我们使用TreeMap集合类基于键对HashMap进行排序。
package beginnersbook.com;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
import java.util.Set;
import java.util.Iterator;
public class Details {
public static void main(String[] args) {
HashMap<Integer, String> hmap = new HashMap<Integer, String>();
hmap.put(5, "A");
hmap.put(11, "C");
hmap.put(4, "Z");
hmap.put(77, "Y");
hmap.put(9, "P");
hmap.put(66, "Q");
hmap.put(0, "R");
System.out.println("Before Sorting:");
Set set = hmap.entrySet();
Iterator iterator = set.iterator();
while(iterator.hasNext()) {
Map.Entry me = (Map.Entry)iterator.next();
System.out.print(me.getKey() + ": ");
System.out.println(me.getValue());
}
Map<Integer, String> map = new TreeMap<Integer, String>(hmap);
System.out.println("After Sorting:");
Set set2 = map.entrySet();
Iterator iterator2 = set2.iterator();
while(iterator2.hasNext()) {
Map.Entry me2 = (Map.Entry)iterator2.next();
System.out.print(me2.getKey() + ": ");
System.out.println(me2.getValue());
}
}
}
输出：
Before Sorting:
0: R
4: Z
5: A
66: Q
9: P
77: Y
11: C
After Sorting:
0: R
4: Z
5: A
9: P
11: C
66: Q
77: Y
HashMap按值排序
在这个例子中，我们使用Comparator按值对HashMap进行排序。
package beginnersbook.com;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class HMapSortingByvalues {
public static void main(String[] args) {
HashMap<Integer, String> hmap = new HashMap<Integer, String>();
hmap.put(5, "A");
hmap.put(11, "C");
hmap.put(4, "Z");
hmap.put(77, "Y");
hmap.put(9, "P");
hmap.put(66, "Q");
hmap.put(0, "R");
System.out.println("Before Sorting:");
Set set = hmap.entrySet();
Iterator iterator = set.iterator();
while(iterator.hasNext()) {
Map.Entry me = (Map.Entry)iterator.next();
System.out.print(me.getKey() + ": ");
System.out.println(me.getValue());
}
Map<Integer, String> map = sortByValues(hmap);
System.out.println("After Sorting:");
Set set2 = map.entrySet();
Iterator iterator2 = set2.iterator();
while(iterator2.hasNext()) {
Map.Entry me2 = (Map.Entry)iterator2.next();
System.out.print(me2.getKey() + ": ");
System.out.println(me2.getValue());
}
}
private static HashMap sortByValues(HashMap map) {
List list = new LinkedList(map.entrySet());
// Defined Custom Comparator here
Collections.sort(list, new Comparator() {
public int compare(Object o1, Object o2) {
return ((Comparable) ((Map.Entry) (o1)).getValue())
.compareTo(((Map.Entry) (o2)).getValue());
}
});
// Here I am copying the sorted list in HashMap
// using LinkedHashMap to preserve the insertion order
HashMap sortedHashMap = new LinkedHashMap();
for (Iterator it = list.iterator(); it.hasNext();) {
Map.Entry entry = (Map.Entry) it.next();
sortedHashMap.put(entry.getKey(), entry.getValue());
}
return sortedHashMap;
}
}
输出：
Before Sorting:
0: R
4: Z
5: A
66: Q
9: P
77: Y
11: C
After Sorting:
5: A
11: C
9: P
66: Q
0: R
77: Y
4: Z
参考：
Java - 获取HashMap的大小
原文： https://beginnersbook.com/2014/07/java-get-size-of-hashmap-example/
在这个例子中，我们将看到如何使用HashMap类的size()方法获取HashMap的大小。方法定义和描述如下：
public int size()：返回此映射中键 - 值映射的数量。
import java.util.HashMap;
public class SizeExample {
public static void main(String[] args) {
// Creating a HashMap of int keys and String values
HashMap<Integer, String> hashmap = new HashMap<Integer, String>();
// Adding Key and Value pairs to HashMap
hashmap.put(11,"Value1");
hashmap.put(22,"Value2");
hashmap.put(33,"Value3");
hashmap.put(44,"Value4");
hashmap.put(55,"Value5");
// int size() method returns the number of key value pairs
System.out.println("Size of HashMap : " + hashmap.size());
}
}
输出：
Size of HashMap : 5
由于我们在HashMap中有 5 个键值对，因此size()方法返回整数 5。另外，在上面的例子中我们采用了Integer键和String值，但是如果你想拥有String键和String值，那么你可以这样改变泛型：
HashMap<String, String> hashmap = new HashMap<String, String>();
请记住，如果您有字符串键和值，添加这样的对。
hashmap.put("11", "Value1");
Java - 从HashMap中删除映射
原文： https://beginnersbook.com/2014/07/java-remove-mapping-from-hashmap-example/
示例
在这个例子中，我们将看到如何使用键值对的键值从HashMap中删除特定的映射。我们将使用以下HashMap类方法来执行此操作：
public Value remove(Object key)：从此映射中移除指定键的映射（如果存在），并返回该特定键的元素值。更多关于remove方法 Javadoc。
完整代码：
import java.util.HashMap;
public class RemoveMappingExample {
public static void main(String[] args) {
// Creating a HashMap of int keys and String values
HashMap<Integer, String> hashmap = new HashMap<Integer, String>();
// Adding Key and Value pairs to HashMap
hashmap.put(11,"Value1");
hashmap.put(22,"Value2");
hashmap.put(33,"Value3");
hashmap.put(44,"Value4");
hashmap.put(55,"Value5");
hashmap.put(66,"Value6");
// Displaying HashMap Elements
System.out.println("HashMap Elements: " + hashmap);
// Removing Key-Value pairs for key 33
Object removedElement1 = hashmap.remove(33);
System.out.println("Element removed is: " +removedElement1);
// Removing Key-Value pairs for key 55
Object removedElement2 = hashmap.remove(55);
System.out.println("Element removed is: " +removedElement2);
// Displaying HashMap Elements after remove
System.out.println("After Remove:");
System.out.println("--------------");
System.out.println("HashMap Elements: " + hashmap);
}
}
输出：
HashMap Elements: {33=Value3, 55=Value5, 66=Value6, 22=Value2, 11=Value1, 44=Value4}
Element removed is: Value3
Element removed is: Value5
After Remove:
--------------
HashMap Elements: {66=Value6, 22=Value2, 11=Value1, 44=Value4}
Java - 从HashMap中删除所有映射
原文： https://beginnersbook.com/2014/07/java-remove-all-mappings-from-hashmap-example/
示例
在上一篇教程中，我们分享了如何根据键从HashMap中删除特定的映射。在这个例子中，我们将看到如何从HashMap中删除所有映射。我们将使用HashMap类的 clear()方法来做到这一点：
public void clear()：从此映射中删除所有映射。此调用返回后，映射将为空。
完整代码：
import java.util.HashMap;
public class RemoveAllExample {
public static void main(String[] args) {
// Creating a HashMap of int keys and String values
HashMap<Integer, String> hashmap = new HashMap<Integer, String>();
// Adding Key and Value pairs to HashMap
hashmap.put(11,"Value1");
hashmap.put(22,"Value2");
hashmap.put(33,"Value3");
hashmap.put(44,"Value4");
hashmap.put(55,"Value5");
// Displaying HashMap Elements
System.out.println("HashMap Elements: " + hashmap);
// Removing all Mapping
hashmap.clear();
// Displaying HashMap Elements after remove
System.out.println("After calling clear():");
System.out.println("---------------------");
System.out.println("HashMap Elements: " + hashmap);
}
}
输出：
HashMap Elements: {33=Value3, 55=Value5, 22=Value2, 11=Value1, 44=Value4}
After calling clear():
---------------------
HashMap Elements: {}
正如您所看到的，在调用clear()方法之后，HashMap的所有映射都已被删除，之后HashMap变为空。
如何检查HashMap是否为空？
原文： https://beginnersbook.com/2014/08/how-to-check-if-a-hashmap-is-empty-or-not/
描述
用于检查HashMap是否为空的程序。我们使用HashMap类的isEmpty()方法来执行此检查。
程序
import java.util.HashMap;
class HashMapIsEmptyExample{
public static void main(String args[]) {
// Create a HashMap
HashMap<Integer, String> hmap = new HashMap<Integer, String>();
// Checking whether HashMap is empty or not
/* isEmpty() method signature and description -
* public boolean isEmpty(): Returns true if this map
* contains no key-value mappings.
*/
System.out.println("Is HashMap Empty? "+hmap.isEmpty());
// Adding few elements
hmap.put(11, "Jack");
hmap.put(22, "Rock");
hmap.put(33, "Rick");
hmap.put(44, "Smith");
hmap.put(55, "Will");
// Checking again
System.out.println("Is HashMap Empty? "+hmap.isEmpty());
}
}
输出：
Is HashMap Empty? true
Is HashMap Empty? false
在HashMap中获取/搜索
Java - 检查HashMap中是否存在特定键
原文： https://beginnersbook.com/2014/07/java-check-if-a-particular-key-exists-in-hashmap-example/
在上一个教程中，我们学习了如何检查HashMap 中是否存在特定值。在这个例子中，我们将看看如何检查HashMap中是否存在特定的键。我们将使用HashMap类的containsKey()方法来执行此检查。方法定义和描述如下：
public boolean containsKey(Object key)：如果此映射包含指定键的映射，则返回true。
示例
我们在以下示例中遵循的步骤是：
1）创建一个HashMap并用键值对填充它。
2）通过调用containsKey()方法检查任何键存在。此方法返回一个布尔值。
import java.util.HashMap;
public class CheckKeyExample {
public static void main(String[] args) {
// Creating a HashMap of int keys and String values
HashMap<Integer, String> hashmap = new HashMap<Integer, String>();
// Adding Key and Value pairs to HashMap
hashmap.put(11,"Chaitanya");
hashmap.put(22,"Pratap");
hashmap.put(33,"Singh");
hashmap.put(44,"Rajesh");
hashmap.put(55,"Kate");
// Checking Key Existence
boolean flag = hashmap.containsKey(22);
System.out.println("Key 22 exists in HashMap? : " + flag);
boolean flag2 = hashmap.containsKey(55);
System.out.println("Key 55 exists in HashMap? : " + flag2);
boolean flag3 = hashmap.containsKey(99);
System.out.println("Key 99 exists in HashMap? : " + flag3);
}
}
输出：
Key 22 exists in HashMap? : true
Key 55 exists in HashMap? : true
Key 99 exists in HashMap? : false
Java - 检查HashMap中是否存在特定值
原文： https://beginnersbook.com/2014/07/java-check-if-a-particular-value-exists-in-hashmap-example/
在这个例子中，我们检查HashMap中是否存在特定值。我们将使用HashMap类的containsValue()方法来执行此检查：
public boolean containsValue(Object value)：如果此映射将一个或多个键映射到指定值，则返回true。
完整代码：
这里我们有一个整数键和字符串值的HashMap，我们正在检查特定的String是否映射到HashMap的任何键。
import java.util.HashMap;
public class CheckValueExample {
public static void main(String[] args) {
// Creating a HashMap of int keys and String values
HashMap<Integer, String> hashmap = new HashMap<Integer, String>();
// Adding Key and Value pairs to HashMap
hashmap.put(11,"Chaitanya");
hashmap.put(22,"Pratap");
hashmap.put(33,"Singh");
hashmap.put(44,"Rajesh");
hashmap.put(55,"Kate");
// Checking Value Existence
boolean flag = hashmap.containsValue("Singh");
System.out.println("String Singh exists in HashMap? : " + flag);
}
}
输出：
String Singh exists in HashMap? : true
ArrayList添加/删除
序列化/同步
如何在 java 中序列化HashMap
原文： https://beginnersbook.com/2013/12/how-to-serialize-hashmap-in-java/
HashMap类默认是序列化的，这意味着我们不需要实现Serializable接口，以使其符合序列化的条件。在本教程中，我们将学习如何编写HashMap对象及其内容到文件和如何从文件中读取HashMap对象。在分享完整代码之前，让我简单介绍一下序列化和反序列化。
序列化：这是一个将Object与其属性和内容一起写入文件的过程。它在内部以字节流转换对象。
反序列化：这是一个从文件中读取Object及其属性以及Object内容的过程。
示例：
HashMap的序列化：在下面的类中，我们将HashMap内容存储在hashmap.ser序列化文件中。运行以下代码后，它将生成一个hashmap.ser文件。此文件将在下一个类中用于反序列化。
package beginnersbook.com;
import java.io.*;
import java.util.HashMap;
public class Details
{
public static void main(String [] args)
{
HashMap<Integer, String> hmap = new HashMap<Integer, String>();
//Adding elements to HashMap
hmap.put(11, "AB");
hmap.put(2, "CD");
hmap.put(33, "EF");
hmap.put(9, "GH");
hmap.put(3, "IJ");
try
{
FileOutputStream fos =
new FileOutputStream("hashmap.ser");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(hmap);
oos.close();
fos.close();
System.out.printf("Serialized HashMap data is saved in hashmap.ser");
}catch(IOException ioe)
{
ioe.printStackTrace();
}
}
}
输出：
Serialized HashMap data is saved in hashmap.ser
反序列化：这里我们正在重现HashMap对象，它是我们通过运行上面的代码创建的序列化文件的内容。
package beginnersbook.com;
import java.io.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
import java.util.Set;
public class Student
{
public static void main(String [] args)
{
HashMap<Integer, String> map = null;
try
{
FileInputStream fis = new FileInputStream("hashmap.ser");
ObjectInputStream ois = new ObjectInputStream(fis);
map = (HashMap) ois.readObject();
ois.close();
fis.close();
}catch(IOException ioe)
{
ioe.printStackTrace();
return;
}catch(ClassNotFoundException c)
{
System.out.println("Class not found");
c.printStackTrace();
return;
}
System.out.println("Deserialized HashMap..");
// Display content using Iterator
Set set = map.entrySet();
Iterator iterator = set.iterator();
while(iterator.hasNext()) {
Map.Entry mentry = (Map.Entry)iterator.next();
System.out.print("key: "+ mentry.getKey() + " & Value: ");
System.out.println(mentry.getValue());
}
}
}
输出：
Deserialized HashMap..
key: 9 & Value: GH
key: 2 & Value: CD
key: 11 & Value: AB
key: 33 & Value: EF
key: 3 & Value: IJ
参考：
HashMap文档SerializablejavadocObjectOutputStreamjavadocObjectInputStream文档FileInputStreamFileOutputStream
如何在 Java 中同步HashMap
原文： https://beginnersbook.com/2013/12/how-to-synchronize-hashmap-in-java-with-example/
HashMap是一个非同步的集合类。如果我们需要对它执行线程安全操作，那么我们必须明确地同步它。在本教程中，我们将了解如何同步HashMap。
示例：
在这个例子中，我们有一个HashMap<Integer, String>它具有整数键和字符串类型值。为了同步它，我们使用Collections.synchronizedMap(hashmap)。它返回由指定的HashMap备份的线程安全映射。
以下示例中需要注意的重要事项：
迭代器应该在同步块中使用，即使我们已经明确地同步了HashMap（正如我们在下面的代码中所做的那样）。
语法：
Map map = Collections.synchronizedMap(new HashMap());
...
//This doesn't need to be in synchronized block
Set set = map.keySet();
// Synchronizing on map, not on set
synchronized (map) {
// Iterator must be in synchronized block
Iterator iterator = set.iterator();
while (iterator.hasNext()){
...
}
}
完整代码：
package beginnersbook.com;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Iterator;
public class HashMapSyncExample {
public static void main(String args[]) {
HashMap<Integer, String> hmap= new HashMap<Integer, String>();
hmap.put(2, "Anil");
hmap.put(44, "Ajit");
hmap.put(1, "Brad");
hmap.put(4, "Sachin");
hmap.put(88, "XYZ");
Map map= Collections.synchronizedMap(hmap);
Set set = map.entrySet();
synchronized(map){
Iterator i = set.iterator();
// Display elements
while(i.hasNext()) {
Map.Entry me = (Map.Entry)i.next();
System.out.print(me.getKey() + ": ");
System.out.println(me.getValue());
}
}
}
}
输出：
1: Brad
2: Anil
4: Sachin
88: XYZ
44: Ajit
差异
HashMap和Hashtable之间的区别
原文： https://beginnersbook.com/2014/06/difference-between-hashmap-and-hashtable/
HashMap和Hashtable有什么区别？这是 Java / J2EE 专业人员常见的面试问题之一。HashMap和Hashtable这两个类实现了java.util.Map接口，但它们的工作方式和用法存在差异。在这里，我们将讨论这些类之间的差异。
HashMap vs Hashtable
1） HashMap是非同步的。这意味着如果它在多线程环境中使用，那么多个线程可以同时访问和处理HashMap。
Hashtable已同步。它确保在给定时刻不超过一个线程可以访问Hashtable。在Hashtable上工作的线程获取一个锁，使其他线程等待，直到它的工作完成。
2）HashMap允许一个空键和任意数量的空值。
Hashtable不允许使用null键和null值。
3）HashMap实现LinkedHashMap 维护插入顺序， TreeMap 根据键的升序对映射进行排序。
Hashtable不保证任何顺序。它不以任何特定顺序维护映射。
4）最初Hashtable不是集合框架的一部分，它在被改进以实现Map接口之后成为了一个集合框架成员。
HashMap实现了Map接口，从一开始就是集合框架的一部分。
5）这些类之间的另一个区别是HashMap的迭代器是一个快速失败并抛出ConcurrentModificationException如果任何其他Thread通过添加或删除除迭代器自己的remove()方法之外的任何元素在结构上修改映射。简单来说，快速失败意味着：当调用iterator.next()时，如果在创建迭代器和调用next()的那一刻之间进行了任何修改，则立即抛出ConcurrentModificationException。
Hashtable的枚举器不是快速失败的。
对于例如
HashMap：
HashMap hm= new HashMap();
....
....
Set keys = hm.keySet();
for (Object key : keys) {
//it will throw the ConcurrentModificationException here
hm.put(object & value pair here);
}
Hashtable：
Hashtable ht= new Hashtable();
....
.....
Enumeration keys = ht.keys();
for (Enumeration en = ht.elements() ; en.hasMoreElements() ; en.nextElement()) {
//No exception would be thrown here
ht.put(key & value pair here);
}
何时使用HashMap和Hashtable？
1）如上所述，HashMap与Hashtable是同步。如果需要线程安全操作，那么可以使用Hashtable，因为它的所有方法都是同步的，但它应该是遗留类，应该避免，因为它没有任何关于它，HashMap无法完成。对于多线程环境，我建议你使用ConcurrentHashMap（几乎类似于 Hashtable），甚至可以使HashMap显式同步（在这里阅读）。
2）同步操作性能较差，因此除非需要，否则应避免使用。因此，对于非线程环境，应该毫无疑问地使用HashMap。
HashSet和HashMap之间的区别
原文： https://beginnersbook.com/2014/08/hashset-vs-hashmap-java/
在本文中，我们将讨论HashSet和HashMap类之间的差异。
HashSet vs HashMap
差异：
HashSet |
HashMap |
|---|---|
HashSet类实现Set接口 |
HashMap类实现了Map接口 |
在HashSet中，我们存储对象（元素或值），例如如果我们有一个字符串元素的HashSet，那么它可以描述一组HashSet元素：{"Hello", "Hi", "Bye", "Run"} |
HashMap 于存储键值对。简而言之，它保持了键和值的映射。（HashMap类大致相当于Hashtable，除了它是不同步的并且允许空值。）如果HashMap元素具有整数键和String类型的值，则可以表示HashMap元素：{1->"Hello", 2->"Hi", 3->"Bye", 4->"Run"} |
HashSet不允许重复元素，这意味着您无法在HashSet中存储重复值。 |
HashMap不允许重复键，但它允许重复值。 |
HashSet允许具有单个空值。 |
HashMap允许单个null键和任意数量的空值。 |
相似之处：
1）HashMap和HashSet都不同步，这意味着它们不适合线程安全操作unitl，除非明确同步。这是你可以明确地同步它们的方法：
HashSet：
Set s = Collections.synchronizedSet(new HashSet(...));
HashMap：
Map m = Collections.synchronizedMap(new HashMap(...));
2）这两个类都不保证其元素的顺序会随着时间的推移保持不变。
3）如果查看HashSet的源代码，您可能会发现它由HashMap备份。所以基本上它在内部使用HashMap进行所有操作。
4）它们都为基本操作提供恒定的时间性能，例如添加，删除元素等。
HashSet示例
import java.util.HashSet;
class HashSetDemo{
public static void main(String[] args) {
// Create a HashSet
HashSet<String> hset = new HashSet<String>();
//add elements to HashSet
hset.add("AA");
hset.add("BB");
hset.add("CC");
hset.add("DD");
// Displaying HashSet elements
System.out.println("HashSet contains: ");
for(String temp : hset){
System.out.println(temp);
}
}
}
输出：
HashSet contains:
AA
BB
CC
DD
HashMap示例
import java.util.HashMap;
class HashMapDemo{
public static void main(String[] args) {
// Create a HashMap
HashMap<Integer, String> hmap = new HashMap<Integer, String>();
//add elements to HashMap
hmap.put(1, "AA");
hmap.put(2, "BB");
hmap.put(3, "CC");
hmap.put(4, "DD");
// Displaying HashMap elements
System.out.println("HashMap contains: "+hmap);
}
}
输出：
HashMap contains: {1=AA, 2=BB, 3=CC, 4=DD}
参考：
HashSet javadoc
HashMap javadoc
关于HashMap的其他教程
Java - HashMap Iterator
原文： https://beginnersbook.com/2014/07/java-hashmap-iterator-example/
示例
在上一个教程中，我们看到了不同的 2 种迭代HashMap的方法。在这个例子中，我们将看到如何使用Iterator迭代HashMap并显示键和值对。我们在下面的例子中遵循的步骤如下：
1）创建HashMap 并用键值对填充它。
2）通过调用entrySet()方法获取键值对集合。
3）获取入口集的迭代器。
4）使用Map.Entry接口的getKey()和getValue()方法显示键值对。
import java.util.HashMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;
public class HashMapIteratorExample {
public static void main(String[] args) {
// Creating a HashMap of int keys and String values
HashMap<Integer, String> hashmap = new HashMap<Integer, String>();
// Adding Key and Value pairs to HashMap
hashmap.put(11,"Value1");
hashmap.put(22,"Value2");
hashmap.put(33,"Value3");
hashmap.put(44,"Value4");
hashmap.put(55,"Value5");
// Getting a Set of Key-value pairs
Set entrySet = hashmap.entrySet();
// Obtaining an iterator for the entry set
Iterator it = entrySet.iterator();
// Iterate through HashMap entries(Key-Value pairs)
System.out.println("HashMap Key-Value Pairs : ");
while(it.hasNext()){
Map.Entry me = (Map.Entry)it.next();
System.out.println("Key is: "+me.getKey() +
" & " +
" value is: "+me.getValue());
}
}
}
输出：
HashMap Key-Value Pairs :
Key is: 33 & value is: Value3
Key is: 55 & value is: Value5
Key is: 22 & value is: Value2
Key is: 11 & value is: Value1
Key is: 44 & value is: Value4
如何将一个hashmap内容复制到另一个hashmap
原文： https://beginnersbook.com/2014/08/how-to-copy-one-hashmap-content-to-another-hashmap/
在本教程中，我们将学习如何将一个 HashMap 元素复制到另一个HashMap。我们将使用HashMap类的putAll()方法来执行此操作。完整代码如下：
import java.util.HashMap;
class HashMapDemo{
public static void main(String[] args) {
// Create a HashMap
HashMap<Integer, String> hmap = new HashMap<Integer, String>();
//add elements to HashMap
hmap.put(1, "AA");
hmap.put(2, "BB");
hmap.put(3, "CC");
hmap.put(4, "DD");
// Create another HashMap
HashMap<Integer, String> hmap2 = new HashMap<Integer, String>();
// Adding elements to the recently created HashMap
hmap2.put(11, "Hello");
hmap2.put(22, "Hi");
// Copying one HashMap "hmap" to another HashMap "hmap2"
hmap2.putAll(hmap);
// Displaying HashMap "hmap2" content
System.out.println("HashMap 2 contains: "+ hmap2);
}
}
输出：
HashMap 2 contains: {1=AA, 2=BB, 3=CC, 4=DD, 22=Hi, 11=Hello}
hmap的所有元素都被复制到hmap2。putAll()操作不会替换Map的现有元素，而是将元素附加到它们。
HashMap - 从键中获取值
原文： https://beginnersbook.com/2014/08/hashmap-get-value-from-key-example/
描述
在提供键时从HashMap获取值的程序。
示例
import java.util.HashMap;
class HashMapDemo{
public static void main(String[] args) {
// Create a HashMap
HashMap<Integer, String> hmap = new HashMap<Integer, String>();
//add elements to HashMap
hmap.put(1, "AA");
hmap.put(2, "BB");
hmap.put(3, "CC");
hmap.put(4, "DD");
// Getting values from HashMap
String val=hmap.get(4);
System.out.println("The Value mapped to Key 4 is:"+ val);
/* Here Key "5" is not mapped to any value so this
* operation returns null.
*/
String val2=hmap.get(5);
System.out.println("The Value mapped to Key 5 is:"+ val2);
}
}
输出：
The Value mapped to Key 4 is:DD
The Value mapped to Key 5 is:null
注意：在上面的程序中，键 5 没有映射到任何值，因此get()方法返回null，但是您不能使用此方法来检查HashMap中是否存在某个键，因为返回值null不一定表示映射不包含键；映射也可能将键明确映射为null。您必须使用containsKey()方法来检查HashMap中键是否存在。
Java ArrayList add()方法
原文： https://beginnersbook.com/2013/12/java-arraylist-add-method-example/
这里我们讨论Java.util.ArrayList类的add()方法。此方法用于向ArrayList添加元素。以下是方法签名：
public boolean add(Object element)
例
package beginnersbook.com;
import java.util.ArrayList;
public class Details {
public static void main(String[] args) {
//ArrayList<String> Declaration
ArrayList<String> al= new ArrayList<String>();
//add method for String ArrayList
al.add("Ram");
al.add("Shyam");
al.add("CPS");
al.add("John");
al.add("Steve");
System.out.println("Elements of ArrayList of String Type: "+al);
//ArrayList<Integer> Declaration
ArrayList<Integer> al2 = new ArrayList<Integer>();
//add method for integer ArrayList
al2.add(1);
al2.add(34);
al2.add(99);
al2.add(99);
al2.add(78);
System.out.println("Elements of ArrayList of Integer Type: "+al2);
}
}
输出：
Elements of ArrayList of String Type: [Ram, Shyam, CPS, John, Steve]
Elements of ArrayList of Integer Type: [1, 34, 99, 99, 78]
参考：
Java - 从HashMap获取键集视图
原文： https://beginnersbook.com/2014/08/java-get-set-view-of-keys-from-hashmap/
描述
程序从HashMap获取键集。
示例
import java.util.Iterator;
import java.util.HashMap;
import java.util.Set;
class HashMapExample{
public static void main(String args[]) {
// Create a HashMap
HashMap<String, String> hmap = new HashMap<String, String>();
// Adding few elements
hmap.put("Key1", "Jack");
hmap.put("Key2", "Rock");
hmap.put("Key3", "Rick");
hmap.put("Key4", "Smith");
hmap.put("Key5", "Will");
// Getting Set of HashMap keys
/* public Set<K> keySet(): Returns a Set view of the keys contained
* in this map. The set is backed by the map, so changes to the map
* are reflected in the set, and vice-versa.
*/
Set<String> keys = hmap.keySet();
System.out.println("Set of Keys contains: ");
/* If your HashMap has integer keys then specify the iterator like
* this: Iterator<Integer> it = keys.iterator();
*/
Iterator<String> it = keys.iterator();
// Displaying keys. Output will not be in any particular order
while(it.hasNext()){
System.out.println(it.next());
}
}
}
输出：
Set of Keys contains:
Key2
Key1
Key4
Key3
Key5
注意：这组键由原始HashMap备份，因此如果从Set中删除任何键，它将自动从HashMap中删除。
用 Java 克隆HashMap
原文： https://beginnersbook.com/2014/08/clone-a-hashmap-in-java/
描述
克隆HashMap的程序。我们将使用HashMap类的以下方法来执行克隆。
public Object clone()：返回此HashMap实例的浅表副本：未克隆键和值本身。
示例
import java.util.HashMap;
class HashMapExample{
public static void main(String args[]) {
// Create a HashMap
HashMap<Integer, String> hmap = new HashMap<Integer, String>();
// Adding few elements
hmap.put(11, "Jack");
hmap.put(22, "Rock");
hmap.put(33, "Rick");
hmap.put(44, "Smith");
hmap.put(55, "Will");
System.out.println("HashMap contains: "+hmap);
// Creating a new HashMap
HashMap<Integer, String> hmap2 = new HashMap<Integer, String>();
// cloning first HashMap in the second one
hmap2=(HashMap)hmap.clone();
System.out.println("Cloned Map contains: "+hmap2);
}
}
输出：
HashMap contains: {33=Rick, 55=Will, 22=Rock, 11=Jack, 44=Smith}
Cloned Map contains: {33=Rick, 55=Will, 22=Rock, 11=Jack, 44=Smith}
TreeMap
Java 中的TreeMap
原文： https://beginnersbook.com/2013/12/treemap-in-java-with-example/
TreeMap是基于红黑树的NavigableMap实现。它根据其键的自然顺序排序。
TreeMap类**实现类似于HashMap类的Map接口。它们之间的主要区别在于HashMap是一个无序集合，而TreeMap按其键的升序排序。TreeMap是非同步的集合类，这意味着除非明确同步，否则它不适合线程安全操作。
TreeMap示例
在这个例子中，我们将键映射和值映射存储到TreeMap中，并且我们在从TreeMap获取数据时获得排序的键值映射。
import java.util.TreeMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;
public class Details {
public static void main(String args[]) {
/* This is how to declare TreeMap */
TreeMap<Integer, String> tmap =
new TreeMap<Integer, String>();
/*Adding elements to TreeMap*/
tmap.put(1, "Data1");
tmap.put(23, "Data2");
tmap.put(70, "Data3");
tmap.put(4, "Data4");
tmap.put(2, "Data5");
/* Display content using Iterator*/
Set set = tmap.entrySet();
Iterator iterator = set.iterator();
while(iterator.hasNext()) {
Map.Entry mentry = (Map.Entry)iterator.next();
System.out.print("key is: "+ mentry.getKey() + " & Value is: ");
System.out.println(mentry.getValue());
}
}
}
输出：
key is: 1 & Value is: Data1
key is: 2 & Value is: Data5
key is: 4 & Value is: Data4
key is: 23 & Value is: Data2
key is: 70 & Value is: Data3
正如您所看到的那样，我们已经以随机顺序插入数据，但是当我们显示TreeMap内容时，我们按照键的升序获得了排序结果。
TreeMap教程
以下是TreeMap类上发布的教程列表：
TreeMap示例- 按值排序
TreeMap TreeMap迭代器示例- 以相反的顺序迭代
TreeMap - 从
TreeMap获取子映射 - 获取
TreeMap的大小 - 从
TreeMap中删除键值映射 - 从
TreeMap中删除所有映射
参考：
TreeMap Iterator示例 - Java
原文： https://beginnersbook.com/2014/07/treemap-iterator-example-java/
在这个例子中，我们使用Iterator和Map.Entry迭代TreeMap。
import java.util.TreeMap;
import java.util.Set;
import java.util.Map;
import java.util.Iterator;
public class TreeMapExample {
public static void main(String[] args) {
// Create a TreeMap
TreeMap<String, String> treemap = new TreeMap<String, String>();
// Add key-value pairs to the TreeMap
treemap.put("Key1","Item1");
treemap.put("Key2","Item2");
treemap.put("Key3","Item3");
treemap.put("Key4","Item4");
treemap.put("Key5","Item5");
// Get a set of the entries
Set set = treemap.entrySet();
// Get an iterator
Iterator it = set.iterator();
// Display elements
while(it.hasNext()) {
Map.Entry me = (Map.Entry)it.next();
System.out.print("Key is: "+me.getKey() + " & ");
System.out.println("Value is: "+me.getValue());
}
}
}
输出：
Key is: Key1 & Value is: Item1
Key is: Key2 & Value is: Item2
Key is: Key3 & Value is: Item3
Key is: Key4 & Value is: Item4
Key is: Key5 & Value is: Item5
参考：
TreeMap javadoc
Iterator javadoc
Map.Entry javadoc
如何在 java 中按值对TreeMap进行排序
原文： https://beginnersbook.com/2014/07/how-to-sort-a-treemap-by-value-in-java/
TreeMap总是根据其键进行排序，但是如果你想根据它的值对它进行排序，那么你可以使用比较器来构建一个逻辑。下面是按值排序TreeMap的完整代码。
import java.util.*;
class TreeMapDemo {
//Method for sorting the TreeMap based on values
public static <K, V extends Comparable<V>> Map<K, V>
sortByValues(final Map<K, V> map) {
Comparator<K> valueComparator =
new Comparator<K>() {
public int compare(K k1, K k2) {
int compare =
map.get(k1).compareTo(map.get(k2));
if (compare == 0)
return 1;
else
return compare;
}
};
Map<K, V> sortedByValues =
new TreeMap<K, V>(valueComparator);
sortedByValues.putAll(map);
return sortedByValues;
}
public static void main(String args[]) {
TreeMap<String, String> treemap = new TreeMap<String, String>();
// Put elements to the map
treemap.put("Key1", "Jack");
treemap.put("Key2", "Rick");
treemap.put("Key3", "Kate");
treemap.put("Key4", "Tom");
treemap.put("Key5", "Steve");
// Calling the method sortByvalues
Map sortedMap = sortByValues(treemap);
// Get a set of the entries on the sorted map
Set set = sortedMap.entrySet();
// Get an iterator
Iterator i = set.iterator();
// Display elements
while(i.hasNext()) {
Map.Entry me = (Map.Entry)i.next();
System.out.print(me.getKey() + ": ");
System.out.println(me.getValue());
}
}
}
输出：
Key1: Jack
Key3: Kate
Key2: Rick
Key5: Steve
Key4: Tom
如何在 Java 中以相反的顺序迭代TreeMap
原文： https://beginnersbook.com/2014/07/how-to-iterate-treemap-in-reverse-order-in-java/
默认情况下，TreeMap元素按键的升序排序。我们可以以相反的顺序迭代TreeMap，以按键的降序显示元素。
以相反的顺序显示TreeMap元素：
import java.util.*;
class TreeMapDemo {
public static void main(String args[]) {
Map<String, String> treemap =
new TreeMap<String, String>(Collections.reverseOrder());
// Put elements to the map
treemap.put("Key1", "Jack");
treemap.put("Key2", "Rick");
treemap.put("Key3", "Kate");
treemap.put("Key4", "Tom");
treemap.put("Key5", "Steve");
Set set = treemap.entrySet();
Iterator i = set.iterator();
// Display elements
while(i.hasNext()) {
Map.Entry me = (Map.Entry)i.next();
System.out.print(me.getKey() + ": ");
System.out.println(me.getValue());
}
}
}
输出：
Key5: Steve
Key4: Tom
Key3: Kate
Key2: Rick
Key1: Jack
如您所见，元素以与键相反的顺序显示。
**更多关于Collections.reverseOrder() javadoc：
public static Comparator reverseOrder()：返回一个比较器，它对实现Comparable接口的对象集合施加自然顺序的反转。 （自然排序是由对象自己的compareTo方法强加的排序。）这使得一个简单的习惯用法可以对反向自然顺序实现Comparable接口的对象的集合（或维护）进行排序（或维护）。例如，假设a是一个字符串数组。然后：Arrays.sort(a, Collections.reverseOrder());
以反向字典（按字母顺序）顺序对数组进行排序。返回的比较器是可序列化的。
返回：
一个比较器，它对实现Comparable接口的对象集合施加自然顺序的反转。
参考：
如何从TreeMap中获取子映射 - Java
原文： https://beginnersbook.com/2014/07/how-to-get-the-sub-map-from-treemap-example-java/
在这个例子中，我们将看到如何从TreeMap获取子映射。我们正在使用TreeMap类的subMap()方法。有关详细信息，请参阅以下程序中的注释。
示例
import java.util.*;
class TreeMapDemo {
public static void main(String args[]) {
// Create a TreeMap
TreeMap<String, String> treemap =
new TreeMap<String, String>();
// Put elements to the map
treemap.put("Key1", "Jack");
treemap.put("Key2", "Rick");
treemap.put("Key3", "Kate");
treemap.put("Key4", "Tom");
treemap.put("Key5", "Steve");
treemap.put("Key6", "Ram");
// Displaying TreeMap elements
System.out.println("TreeMap Contains : " + treemap);
// Getting the sub map
/* public SortedMap<K,V> subMap(K fromKey,K toKey): Returns
* a view of the portion of this map whose keys range from
* fromKey, inclusive, to toKey, exclusive.
* (If fromKey and toKey are equal, the returned map is empty.)
* The returned map is backed by this map, so changes in the
* returned map are reflected in this map, and vice-versa.
* The returned map supports all optional map operations that
* this map supports.
*/
SortedMap<String, String> sortedMap = treemap.subMap("Key2","Key5");
System.out.println("SortedMap Contains : " + sortedMap);
// Removing an element from Sub Map
sortedMap.remove("Key4");
/* Displaying elements of original TreeMap after
* removing an element from the Sub Map. Since Sub Map is
* backed up by original Map, the element should be removed
* from this TreeMap too.
*/
System.out.println("TreeMap Contains : " + treemap);
}
}
输出：
TreeMap Contains : {Key1=Jack, Key2=Rick, Key3=Kate, Key4=Tom, Key5=Steve, Key6=Ram}
SortedMap Contains : {Key2=Rick, Key3=Kate, Key4=Tom}
TreeMap Contains : {Key1=Jack, Key2=Rick, Key3=Kate, Key5=Steve, Key6=Ram}
参考：
subMap()方法 - TreeMap javadoc
SortedMap javadoc
LinkedHashMap
Java 中的LinkedHashMap
原文： https://beginnersbook.com/2013/12/linkedhashmap-in-java/
LinkedHashMap 是Map接口的哈希表和链表实现，具有可预测的迭代顺序。此实现与HashMap的不同之处在于它维护了一个贯穿其所有条目的双向链表。此链表定义迭代排序，通常是键插入映射的顺序（插入顺序）。在最后几篇教程中，我们讨论了HashMap和TreeMap。这个类与它们不同：
HashMap没有维持任何顺序。TreeMap按键的升序对条目进行排序。LinkedHashMap保持插入顺序。
让我们借助一个例子来理解LinkedHashMap：
import java.util.LinkedHashMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;
public class LinkedHashMapDemo {
public static void main(String args[]) {
// HashMap Declaration
LinkedHashMap<Integer, String> lhmap =
new LinkedHashMap<Integer, String>();
//Adding elements to LinkedHashMap
lhmap.put(22, "Abey");
lhmap.put(33, "Dawn");
lhmap.put(1, "Sherry");
lhmap.put(2, "Karon");
lhmap.put(100, "Jim");
// Generating a Set of entries
Set set = lhmap.entrySet();
// Displaying elements of LinkedHashMap
Iterator iterator = set.iterator();
while(iterator.hasNext()) {
Map.Entry me = (Map.Entry)iterator.next();
System.out.print("Key is: "+ me.getKey() +
"& Value is: "+me.getValue()+"\n");
}
}
}
输出：
Key is: 22& Value is: Abey
Key is: 33& Value is: Dawn
Key is: 1& Value is: Sherry
Key is: 2& Value is: Karon
Key is: 100& Value is: Jim
如您所见，值的返回顺序与插入的顺序相同。
Java ArrayList add(int index, E element)
原文： https://beginnersbook.com/2013/12/java-arraylist-addint-index-e-element-example/
简单的add()方法用于在列表的末尾添加元素，但是add方法的另一种变体用于向指定的索引添加元素。
public void add(int index, Object element)
此方法在给定索引处添加元素。
例
package beginnersbook.com;
import java.util.ArrayList;
public class AddMethodExample {
public static void main(String[] args) {
// ArrayList of String type
ArrayList<String> al = new ArrayList<String>();
// simple add() methods for adding elements at the end
al.add("Hi");
al.add("hello");
al.add("String");
al.add("Test");
//adding element to the 4th position
//4th position = 3 index as index starts with 0
al.add(3,"Howdy");
System.out.println("Elements after adding string Howdy:"+ al);
//adding string to 1st position
al.add(0, "Bye");
//Print
System.out.println("Elements after adding string bye:"+ al);
}
}
输出：
Elements after adding string Howdy:[Hi, hello, String, Howdy, Test]
Elements after adding string bye:[Bye, Hi, hello, String, Howdy, Test]
参考
[ArrayList.add(int,E)](https://docs.oracle.com/javase/6/docs/api/java/util/ArrayList.html#add(int, E))
HashTable
java 中的Hashtable
原文： https://beginnersbook.com/2014/07/hashtable-in-java-with-example/
该类实现了一个哈希表，它将键映射到值。任何非null对象都可以用作键或值。Hashtable类似于HashMap，但它是同步的。HashMap和Hashtable类之间几乎没有什么区别，你可以在以下网址详细阅读：HashMap和Hashtable之间的区别。
在本教程中，我们将了解如何创建Hashtable，如何填充其条目，然后我们将学习如何使用Enumeration显示其键值对。在本文的最后，我们将看到Hashtable类的Hashtable教程和方法。
示例
import java.util.Hashtable;
import java.util.Enumeration;
public class HashtableExample {
public static void main(String[] args) {
Enumeration names;
String key;
// Creating a Hashtable
Hashtable<String, String> hashtable =
new Hashtable<String, String>();
// Adding Key and Value pairs to Hashtable
hashtable.put("Key1","Chaitanya");
hashtable.put("Key2","Ajeet");
hashtable.put("Key3","Peter");
hashtable.put("Key4","Ricky");
hashtable.put("Key5","Mona");
names = hashtable.keys();
while(names.hasMoreElements()) {
key = (String) names.nextElement();
System.out.println("Key: " +key+ " & Value: " +
hashtable.get(key));
}
}
}
输出：
Key: Key4 & Value: Ricky
Key: Key3 & Value: Peter
Key: Key2 & Value: Ajeet
Key: Key1 & Value: Chaitanya
Key: Key5 & Value: Mona
Hashtable教程
Hashtable示例- 排序
Hashtable Hashtable Iterator示例- 检查
Hashtable中的键值是否存在 - 从
Hashtable中删除映射 - 从
Hashtable中删除所有映射 - 获取
Hashtable的大小 HashtablevsHashMap
Hashtable类的方法：
1）void clear()：从Hashtable中删除所有键值映射并使其为空。清除此哈希表，使其不包含任何键。
2）Object clone()：创建此哈希表的浅表副本。复制哈希表本身的所有结构，但不克隆键和值。这是一项相对昂贵的操作。
3）boolean contains(Object value)：测试某个键是否映射到此哈希表中的指定值。此操作比containsKey方法更昂贵。
请注意，此方法的功能与containsValue相同（它是集合框架中Map接口的一部分）。
4）boolean isEmpty()：测试此哈希表是否将键没有映射到值。
5）Enumeration keys()：返回哈希表中包含的键的枚举。
6）Object put(Object key, Object value)：将指定的键映射到此哈希表中的指定值。
7）void rehash()：增加哈希表的大小并重新哈希其所有键。
8）Object remove(Object key)：从该哈希表中删除键（及其对应的值）。
9）int size()：返回 Hashtable 中存在的键值映射的数量。
10）String toString()：返回哈希表的等效字符串。
11）boolean containsKey(Object key)：测试指定的对象是否是此哈希表中的键。
12）boolean containsValue（Object value）：测试指定的对象是否为此哈希表中的值。如果哈希表中存在某个等于value的值，则返回true。如果未找到该值，则返回false。
13）Enumeration elements()：返回哈希表中包含的值的枚举。
14）Object get(Object key)：返回指定键映射到的值，如果此映射不包含键的映射，则返回null。
参考：
Java 集合 - Iterator/ListIterator
Java Iterator
原文： https://beginnersbook.com/2014/06/java-iterator-with-examples/
Iterator用于迭代（循环）各种集合类，如HashMap，ArrayList，LinkedList等。在本教程中，我们将学习什么是迭代器，如何使用它以及使用它时会出现什么问题。Iterator取代了Enumeration，它用于迭代传统的类，如Vector。我们还将在本教程中看到Iterator和Enumeration之间的差异。
没有泛型示例的迭代器
泛型在 Java 5 中引入。在此之前，没有泛型的概念。
import java.util.ArrayList;
import java.util.Iterator;
public class IteratorDemo1 {
public static void main(String args[]){
ArrayList names = new ArrayList();
names.add("Chaitanya");
names.add("Steve");
names.add("Jack");
Iterator it = names.iterator();
while(it.hasNext()) {
String obj = (String)it.next();
System.out.println(obj);
}
}
}
输出：
Chaitanya
Steve
Jack
在上面的例子中，我们在不使用泛型的情况下迭代了ArrayList。程序运行正常没有任何问题，但是如果你不使用泛型可能有ClassCastException（我们将在下一节中看到这一点）。
另见它们：
具有泛型的迭代器示例
在上一节中，我们讨论了ClassCastException。让我们看看它是什么以及为什么当我们不使用泛型时它会发生。
import java.util.ArrayList;
import java.util.Iterator;
public class IteratorDemo2 {
public static void main(String args[]){
ArrayList names = new ArrayList();
names.add("Chaitanya");
names.add("Steve");
names.add("Jack");
//Adding Integer value to String ArrayList
names.add(new Integer(10));
Iterator it = names.iterator();
while(it.hasNext()) {
String obj = (String)it.next();
System.out.println(obj);
}
}
}
输出：
ChaitanyaException in thread "main"
Steve
Jack
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
at beginnersbook.com.Details.main(Details.java:18)
在上面的程序中，我们尝试将Integer值添加到String的ArrayList中，但是我们没有得到任何编译时错误，因为我们没有使用泛型。但是，由于我们在while循环中键入了将整数值转换为String，因此我们得到了ClassCastException。
使用泛型：
这里我们使用泛型，所以我们没有输入输出转换。如果您尝试在下面的程序中向ArrayList添加一个整数值，则会出现编译时错误。这样我们就可以避免ClassCastException。
import java.util.ArrayList;
import java.util.Iterator;
public class IteratorDemo3 {
public static void main(String args[]){
ArrayList<String> names = new ArrayList<String>();
names.add("Chaitanya");
names.add("Steve");
names.add("Jack");
Iterator<String> it = names.iterator();
while(it.hasNext()) {
String obj = it.next();
System.out.println(obj);
}
}
}
注意：我们没有转换输入和iterator返回值[it.next()]，因为在使用泛型时不需要它。
Iterator和枚举之间的区别
集合上的Iterator。Iterator取代了 Java 集合框架中的Enumeration。迭代器在两个方面与枚举不同：
1）迭代器允许调用者在迭代期间使用明确定义的语义从底层集合中删除元素。
2）方法名称已得到改进。迭代的hashNext()方法替换了枚举的hasMoreElements()方法，同样next()替换了nextElement()。
使用Iterator时出现ConcurrentModificationException
import java.util.ArrayList;
public class ExceptionDemo {
public static void main(String args[]){
ArrayList<String> books = new ArrayList<String>();
books.add("C");
books.add("Java");
books.add("Cobol");
for(String obj : books) {
System.out.println(obj);
//We are adding element while iterating list
books.add("C++");
}
}
}
输出：
C
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
at java.util.ArrayList$Itr.next(Unknown Source)
at beginnersbook.com.Details.main(Details.java:12)
在迭代器上使用迭代器时，我们无法添加或删除元素。
解释自 Javadoc：
当不允许进行此类修改时，检测到并发修改对象的方法可能抛出此异常。
例如，另一个线程迭代它时，一个线程通常不允许修改Collection。通常，在这些情况下，迭代的结果是不确定的。如果检测到此行为，某些Iterator实现（包括 JRE 提供的所有通用集合实现的实现）可能会选择抛出此异常。执行此操作的迭代器称为失败快速迭代器，因为它们快速而干净地失败，而不是在未来的未确定时间冒着任意的，非确定性行为的风险。
Java 中的ListIterator
原文： https://beginnersbook.com/2014/06/listiterator-in-java-with-examples/
在上一个教程中，我们讨论了 Java 中的迭代器，我们可以使用它来向前遍历List或Set。在这里，我们将讨论ListIterator，它允许我们在两个方向（向前和向后）遍历列表。
ListIterator示例
在这个例子中，我们在两个方向上遍历ArrayList 。
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class ListIteratorExample {
public static void main(String a[]){
ListIterator<String> litr = null;
List<String> names = new ArrayList<String>();
names.add("Shyam");
names.add("Rajat");
names.add("Paul");
names.add("Tom");
names.add("Kate");
//Obtaining list iterator
litr=names.listIterator();
System.out.println("Traversing the list in forward direction:");
while(litr.hasNext()){
System.out.println(litr.next());
}
System.out.println("\nTraversing the list in backward direction:");
while(litr.hasPrevious()){
System.out.println(litr.previous());
}
}
}
输出：
Traversing the list in forward direction:
Shyam
Rajat
Paul
Tom
Kate
Traversing the list in backward direction:
Kate
Tom
Paul
Rajat
Shyam
注意：我们可以使用Iterator遍历List和Set两者但是使用ListIterator我们只能遍历List。Iterator和ListIterator之间还有其他一些差异，我们将在下一篇文章中讨论它们。
ListIterator 的方法
1）void add(E e)：将指定的元素插入列表（可选操作）。
2）boolean hasNext()：如果此列表迭代器在向前遍历列表时具有更多元素，则返回true。
3）boolean hasPrevious()：如果此列表迭代器在反向遍历列表时具有更多元素，则返回true。
4）E next()：返回列表中的下一个元素并前进光标位置。
5）int nextIndex()：返回后续调用next()返回的元素的索引。
6）E previous()：返回列表中的上一个元素并向后移动光标位置。
7）int previousIndex()：返回后续调用previous()返回的元素的索引。
8）void remove()：从列表中删除next()或previous()返回的最后一个元素（可选操作）。
9）void set(E e)：用指定的元素（可选操作）替换next()或previous()返回的最后一个元素。
参考：
Comparable和Comparator接口
Java 中的Comparable接口
原文： https://beginnersbook.com/2017/08/comparable-interface-in-java-with-example/
Comparable接口主要用于对自定义对象的数组（或列表）进行排序。
实现Comparable接口的对象列表（和数组）可以由Collections.sort（和Arrays.sort）自动排序。在我们看到如何对自定义对象的对象进行排序之前，让我们看看如何对已经实现 Comparable的数组元素和包装器类进行排序。
示例：对数组和包装器类进行排序
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class Demo {
public static void main(String[] args) {
/*
* Integer class implements Comparable
* Interface so we can use the sort method
*/
int[] arr = {11,55,22,0,89};
Arrays.sort(arr);
System.out.print("Sorted Int Array: ");
System.out.println(Arrays.toString(arr));
/*
* String class implements Comparable
* Interface so we can use the sort method
*/
System.out.print("Sorted String Array: ");
String[] names = {"Steve", "Ajeet", "Kyle"};
Arrays.sort(names);
System.out.println(Arrays.toString(names));
/*
* String class implements Comparable
* Interface so we can use the sort method
*/
System.out.print("Sorted List: ");
List fruits = new ArrayList();
fruits.add("Orange");
fruits.add("Banana");
fruits.add("Apple");
fruits.add("Guava");
fruits.add("Grapes");
Collections.sort(fruits);
for(String s: fruits) System.out.print(s+", ");
}
}
输出：
Sorted Int Array: [0, 11, 22, 55, 89]
Sorted String Array: [Ajeet, Kyle, Steve]
Sorted List: Apple, Banana, Grapes, Guava, Orange,
在上面的示例中，您已经看到对实现Comparable接口的数组和对象列表进行排序是多么容易，您只需要调用Collections.sort（和Arrays.sort）。
但是，如果要对自定义类的对象进行排序，则需要在自定义类中实现Comparable接口。
该接口只有一个方法：
public abstract int compareTo(T obj)
由于此方法是抽象的，因此如果实现Comparable接口，则必须在类中实现此方法。
让我们举个例子来更好地理解这个：
示例：通过实现Comparable接口对自定义对象进行排序
正如您所看到的，我在Author类中实现了Comparable接口，因为我想对这个类的对象进行排序。我已经在compareTo()方法中编写了排序逻辑，您可以根据需求编写逻辑。我想先按姓氏排序作者姓名，如果姓氏相同，则按名字排序。如果您只想按姓氏排序，那么compareTo()方法中的第一行就足够了。
Author类
public class Author implements Comparable<Author> {
String firstName;
String lastName;
String bookName;
Author(String first, String last, String book){
this.firstName = first;
this.lastName = last;
this.bookName = book;
}
@Override
/*
* This is where we write the logic to sort. This method sort
* automatically by the first name in case that the last name is
* the same.
*/
public int compareTo(Author au){
/*
* Sorting by last name. compareTo should return < 0 if this(keyword)
* is supposed to be less than au, > 0 if this is supposed to be
* greater than object au and 0 if they are supposed to be equal.
*/
int last = this.lastName.compareTo(au.lastName);
//Sorting by first name if last name is same d
return last == 0 ? this.firstName.compareTo(au.firstName) : last;
}
}
排序类：SortAuthByNames
import java.util.ArrayList;
import java.util.Collections;
public class SortAuthByNames{
public static void main(String args[]){
// List of objects of Author class
ArrayList<Author> al=new ArrayList<Author>();
al.add(new Author("Henry","Miller", "Tropic of Cancer"));
al.add(new Author("Nalo","Hopkinson", "Brown Girl in the Ring"));
al.add(new Author("Frank","Miller", "300"));
al.add(new Author("Deborah","Hopkinson", "Sky Boys"));
al.add(new Author("George R. R.","Martin", "Song of Ice and Fire"));
/*
* Sorting the list using Collections.sort() method, we
* can use this method because we have implemented the
* Comparable interface in our user defined class Author
*/
Collections.sort(al);
for(Author str:al){
System.out.println(str.firstName+" "+
str.lastName+" "+"Book: "+str.bookName);
}
}
}
输出：
Deborah Hopkinson Book: Sky Boys
Nalo Hopkinson Book: Brown Girl in the Ring
George R. R. Martin Book: A Song of Ice and Fire
Frank Miller Book: 300
Henry Miller Book: Tropic of Cancer
注意：我们应该以这样的方式编写
compareTo()方法：如果这个（我在这里指的是this关键字）小于传递的对象那么它应该返回负数，如果大于正数则为零，如果相等则返回 0。
你可能想知道为什么我没有写那个逻辑？因为名字和姓氏是字符串，所以我调用了字符串类的compareTo()方法，它完全相同。
但是如果我们比较的东西是其他类型的东西，比如int那么你就可以编写这样的逻辑：
假设Employee类的对象是（empId，empName，empAge），我们想通过empAge对对象进行排序]。
public int compareTo(Employee e){
if(this.empAge==e.empAge)
return 0;
else if(this.empAge>e.empAge)
return 1;
else
return -1;
}
或
public int compareTo(Employee e){
return this.empAge > e.empAge ? 1 : this.empAge < e.empAge ? -1 : 0;
}
Java 中的Comparator接口
原文： https://beginnersbook.com/2017/08/comparator-interface-in-java/
在最后一个教程中，我们已经了解了如何使用Comparable接口对自定义类的对象进行排序。通过使用Comparable，我们可以根据任何数据成员对对象进行排序。例如，假设我们有一个Author类有数据成员：作者姓名，书名和作者年龄，现在如果我们想根据任何数据成员对对象进行排序那么我们可以使用Comparable但是如果我们想要有多个排序选项，并且我们可以根据任何选择对对象进行排序，这可以使用Comparator接口完成，我们可以创建尽可能多的Comparator然后我们可以在一个或多个上调用Collections.sort这样的比较器：
//Sorting arraylist al by Author Age
Collections.sort(al, new AuthorAgeComparator());
//Sorting arraylist al by Book Name
Collections.sort(al, new BookNameComparator());
那么它是怎样工作的？要像这样调用Collections.sort方法，我们必须首先编写这些Comparator 类AuthorAgeComparator和BookNameComparator，以及Author类和Main类。
完整的比较示例
Author.java
public class Author implements Comparable<Author> {
String firstName;
String bookName;
int auAge;
Author(String first, String book, int age){
this.firstName = first;
this.bookName = book;
this.auAge = age;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getBookName() {
return bookName;
}
public void setBookName(String bookName) {
this.bookName = bookName;
}
public int getAuAge() {
return auAge;
}
public void setAuAge(int auAge) {
this.auAge = auAge;
}
@Override
/*
* When we only use Comparable, this is where we write sorting
* logic. This method is called when we implement the Comparable
* interface in our class and call Collections.sort()
*/
public int compareTo(Author au){
return this.firstName.compareTo(au.firstName);
}
}
AuthorAgeComparator.java
import java.util.*;
class AuthorAgeComparator implements Comparator<Author>{
public int compare(Author a1,Author a2){
if(a1.auAge==a2.auAge)
return 0;
else if(a1.auAge>a2.auAge)
return 1;
else
return -1;
}
}
BookNameComparator.java
import java.util.*;
public class BookNameComparator implements Comparator<Author>{
public int compare(Author a1,Author a2){
return a1.bookName.compareTo(a2.bookName);
}
}
SortingPgm.java
import java.util.ArrayList;
import java.util.Collections;
public class SortingPgm{
public static void main(String args[]){
// List of objects of Author class
ArrayList<Author> al=new ArrayList<Author>();
al.add(new Author("Henry", "Tropic of Cancer", 45));
al.add(new Author("Nalo", "Brown Girl in the Ring", 56));
al.add(new Author("Frank", "300", 65));
al.add(new Author("Deborah", "Sky Boys", 51));
al.add(new Author("George R. R.", "A Song of Ice and Fire", 62));
/*
* Sorting the list using Collections.sort() method, we
* can use this method because we have implemented the
* Comparable interface in our user defined class Author
*/
System.out.println("Sorting by Author First Name:");
Collections.sort(al);
for(Author au: al){
System.out.println(au.getFirstName()+", "+au.getBookName()+", "+
au.getAuAge());
}
/*Sorting using AuthorAgeComparator*/
System.out.println("Sorting by Author Age:");
Collections.sort(al, new AuthorAgeComparator());
for(Author au: al){
System.out.println(au.getFirstName()+", "+au.getBookName()+", "+
au.getAuAge());
}
/*Sorting using BookNameComparator*/
System.out.println("Sorting by Book Name:");
Collections.sort(al, new BookNameComparator());
for(Author au: al){
System.out.println(au.getFirstName()+", "+au.getBookName()+", "+
au.getAuAge());
}
}
}
输出：
Sorting by Author First Name:
Deborah, Sky Boys, 51
Frank, 300, 65
George R. R., A Song of Ice and Fire, 62
Henry, Tropic of Cancer, 45
Nalo, Brown Girl in the Ring, 56
Sorting by Author Age:
Henry, Tropic of Cancer, 45
Deborah, Sky Boys, 51
Nalo, Brown Girl in the Ring, 56
George R. R., A Song of Ice and Fire, 62
Frank, 300, 65
Sorting by Book Name:
Frank, 300, 65
George R. R., A Song of Ice and Fire, 62
Nalo, Brown Girl in the Ring, 56
Deborah, Sky Boys, 51
Henry, Tropic of Cancer, 45
集合面试问题
Java 集合面试问题和解答
原文： https://beginnersbook.com/2015/03/java-collections-interview-questions-and-answers/
之前我在 Java 集合框架上分享了 100+ 教程。在本文中，我将分享有关 Java 集合框架的面试问题。如果您不熟悉集合，我建议您在完成以下问题集之前参考这些教程，因为它们可以帮助您学习集合的基础知识。开始吧…
几乎在每次面试中，您都会被要求解释两个集合类或两个集合界面之间的差异，“差异”问题在访问者中变得如此受欢迎，以至于他们在访谈期间提出了大约 90%的问题。我几乎涵盖了所有常见的收藏差异。他们是：
Q）ArrayList和Vector有什么区别？
A）参考文章：Arraylist vs. Vector
Q）ArrayList和LinkedList有什么区别？
问：HashMap和Hashtable有什么区别？
A）参考：HashMap与Hashtable
问：HashSet和TreeSet有什么区别？
A）参考：HashSet vs. TreeSet
问）ArrayList和HashMap有什么区别？
问）List，Set和Map接口有什么区别？
A）参考：List，Set和Map
问：Iterator和ListIterator有什么区别？
问：Iterator和Enumeraton有什么区别？
A）以下是它们之间的一些差异：
1）Iteator可用于遗留（Vector等）类以及非遗留类（ArrayList，LinkedList等），而枚举基本上用于传统类，如Vector。
2）迭代器比枚举慢。
3）迭代器是失败快速的，而枚举则不是。
Q）如何同步HashMap？
A）参考：HashMap同步。
Q）如何同步ArrayList？
A）参考：ArrayList同步。
问：故障快速和故障安全有什么区别？
A）当底层集合中存在结构修改时，快速失败的Iterator抛出ConcurrentModificationException，而故障安全的Iterator，在检测到结构修改时不会抛出任何异常，因为故障安全迭代器与底层集合的克隆一起工作。
Q）如何将数组转换为ArrayList？
A）参考：数组到ArrayList的转换。
问）如何从ArrayList中删除重复的元素？
A）参考本教程。
Q）如何循环ArrayList？
A）参考本教程。
Java ArrayList addAll(Collection c)方法
原文： https://beginnersbook.com/2013/12/java-arraylist-addallcollection-c-method-example/
在本教程中，我们将看到java.util.ArrayList class的addAll()方法的用法。此方法用于将列表的所有元素添加到另一个列表。
public boolean addAll(Collection c)
它将指定Collection c的所有元素添加到当前列表中。
例
在这个例子中，我们使用addAll()方法将arraylist的所有元素添加到另一个arraylist。
package beginnersbook.com;
import java.util.ArrayList;
public class ExampleOfaddAll {
public static void main(String[] args) {
// ArrayList1 of String type
ArrayList<String> al = new ArrayList<String>();
al.add("Hi");
al.add("hello");
al.add("String");
al.add("Test");
System.out.println("ArrayList1 before addAll:"+al);
//ArrayList2 of String Type
ArrayList<String> al2 = new ArrayList<String>();
al2.add("Text1");
al2.add("Text2");
al2.add("Text3");
al2.add("Text4");
//Adding ArrayList2 into ArrayList1
al.addAll(al2);
System.out.println("ArrayList1 after addAll:"+al);
}
}
输出：
ArrayList1 before addAll:[Hi, hello, String, Test]
ArrayList1 after addAll:[Hi, hello, String, Test, Text1, Text2, Text3, Text4]
参考：
ArrayList.addAll(Collection c)
如何在 Java 中将所有List元素复制并添加到ArrayList
原文： https://beginnersbook.com/2013/12/how-to-copy-and-add-all-list-elements-to-arraylist-in-java/
在本教程中，我们将了解如何将列表的所有元素复制并添加到ArrayList。为此，我们将使用ArrayList类的addAll method。
public boolean addAll(Collection c)
它将指定的Collection c 的所有元素添加到调用列表的末尾。如果指定的Collection为空，则抛出NullPointerException。
将List元素复制到ArrayList的完整示例
package beginnersbook.com;
import java.util.ArrayList;
import java.util.List;
public class ListToArrayListExample {
public static void main(String a[]){
ArrayList<String> al = new ArrayList<String>();
//Adding elements to the ArrayList
al.add("Text 1");
al.add("Text 2");
al.add("Text 3");
System.out.println("ArrayList Elements are: "+al);
//Adding elements to a List
List<String> list = new ArrayList<String>();
list.add("Text 4");
list.add("Text 5");
list.add("Text 6");
//Adding all lements of list to ArrayList using addAll
al.addAll(list);
System.out.println("Updated ArrayList Elements: "+al);
}
}
输出：
ArrayList Elements are: [Text 1, Text 2, Text 3]
Updated ArrayList Elements: [Text 1, Text 2, Text 3, Text 4, Text 5, Text 6]
Java ArrayList addAll(int index, Collection c)方法
原文： https://beginnersbook.com/2013/12/java-arraylist-addall-int-index-collection-c-method-example/
在上一个教程中，我们共享了addAll(Collection c)方法的示例，该方法用于在列表末尾添加Collection c的所有元素。在这里，我们将看到另一个变体add(int index, Collection c)，它在列表的指定索引处添加c的所有元素。
public boolean addAll(int index, Collection c)
例
在这个例子中，我们有两个String类型的ArrayList，我们在第一个arraylist的第 3 个位置（index = 2）添加第二个arraylist的元素。
package beginnersbook.com;
import java.util.ArrayList;
public class ExampleOfaddAllMethod {
public static void main(String[] args) {
// ArrayList1
ArrayList<String> al = new ArrayList<String>();
al.add("Apple");
al.add("Orange");
al.add("Grapes");
al.add("Mango");
System.out.println("ArrayList1 before addAll:"+al);
//ArrayList2
ArrayList<String> al2 = new ArrayList<String>();
al2.add("Fig");
al2.add("Pear");
al2.add("Banana");
al2.add("Guava");
System.out.println("ArrayList2 content:"+al2);
//Adding ArrayList2 in ArrayList1 at 3rd position(index =2)
al.addAll(2, al2);
System.out.println("ArrayList1 after adding ArrayList2 at 3rd Pos:\n"+al);
}
}
输出：
ArrayList1 before addAll:[Apple, Orange, Grapes, Mango]
ArrayList2 content:[Fig, Pear, Banana, Guava]
ArrayList1 after adding ArrayList2 at 3rd Pos:
[Apple, Orange, Fig, Pear, Banana, Guava, Grapes, Mango]
参考：
[addAll(int, Collection)](https://docs.oracle.com/javase/6/docs/api/java/util/ArrayList.html#addAll(int, java.util.Collection))
Java ArrayList remove(int index)方法
原文： https://beginnersbook.com/2013/12/java-arraylist-remove-method-example/
方法remove(int index)用于从列表中删除指定索引的元素。它删除一个元素并返回相同的元素。如果指定的索引小于零或大于列表的大小（ArrayList的索引大小），则抛出IndexOutOfBoundsException。
public Object remove(int index)
例
package beginnersbook.com;
import java.util.ArrayList;
public class RemoveExample {
public static void main(String args[]) {
//String ArrayList
ArrayList<String> al = new ArrayList<String>();
al.add("AB");
al.add("CD");
al.add("EF");
al.add("GH");
al.add("AB");
al.add("YZ");
System.out.println("ArrayList before remove:");
for(String var: al){
System.out.println(var);
}
//Removing 1st element
al.remove(0);
//Removing 3rd element from the remaining list
al.remove(2);
//Removing 4th element from the remaining list
al.remove(2);
System.out.println("ArrayList After remove:");
for(String var2: al){
System.out.println(var2);
}
}
}
输出：
ArrayList before remove:
AB
CD
EF
GH
AB
YZ
ArrayList After remove:
CD
EF
YZ
Java 集合 - List
Java ArrayList remove(Object obj)方法
原文： https://beginnersbook.com/2013/12/java-arraylist-removeobject-method-example/
方法remove(Object obj)从列表中删除指定的对象。它属于java.util.ArrayList类。
public boolean remove(Object obj)
注：
- 如果列表中不存在指定的元素，则返回
false。 - 如果列表中存在重复元素，则会从列表中删除指定元素的第一个匹配项。
例
在这个例子中，我们有一个ArrayList<String>我们正从列表中删除一些字符串。
package beginnersbook.com;
import java.util.ArrayList;
public class RemoveExample {
public static void main(String args[]) {
//String ArrayList
ArrayList<String> al = new ArrayList<String>();
al.add("AA");
al.add("BB");
al.add("CC");
al.add("DD");
al.add("EE");
al.add("FF");
System.out.println("ArrayList before remove:");
for(String var: al){
System.out.println(var);
}
//Removing element AA from the arraylist
al.remove("AA");
//Removing element FF from the arraylist
al.remove("FF");
//Removing element CC from the arraylist
al.remove("CC");
/*This element is not present in the list so
* it should return false
*/
boolean b=al.remove("GG");
System.out.println("Element GG removed: "+b);
System.out.println("ArrayList After remove:");
for(String var2: al){
System.out.println(var2);
}
}
}
输出：
ArrayList before remove:
AA
BB
CC
DD
EE
FF
Element GG removed: false
ArrayList After remove:
BB
DD
EE
在ArrayList中获取/搜索
如何获取ArrayList的子列表
原文： https://beginnersbook.com/2013/12/how-to-get-sublist-of-an-arraylist-with-example/
在本教程中，我们将了解如何从现有ArrayList获取子列表。我们将使用ArrayList类的[subList](https://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html#subList(int, int))方法来完成它。
List subList(int fromIndex, int toIndex)
这里fromIndex是包容性的，toIndex是独占的。关于这种方法，我在本文末尾分享了一些重要的观点。
从ArrayList获取子列表的示例
以下示例中的注意事项：
subList方法返回一个列表，因此将子列表存储在另一个ArrayList中，我们必须以与下面示例中相同的方式对返回值进行类型转换。另一方面，如果我们将返回的子列表存储到列表中，则无需键入转换（请参阅示例）。
package beginnersbook.com;
import java.util.ArrayList;
import java.util.List;
public class SublistExample {
public static void main(String a[]){
ArrayList<String> al = new ArrayList<String>();
//Addition of elements in ArrayList
al.add("Steve");
al.add("Justin");
al.add("Ajeet");
al.add("John");
al.add("Arnold");
al.add("Chaitanya");
System.out.println("Original ArrayList Content: "+al);
//Sublist to ArrayList
ArrayList<String> al2 = new ArrayList<String>(al.subList(1, 4));
System.out.println("SubList stored in ArrayList: "+al2);
//Sublist to List
List<String> list = al.subList(1, 4);
System.out.println("SubList stored in List: "+list);
}
}
输出：
Original ArrayList Content: [Steve, Justin, Ajeet, John, Arnold, Chaitanya]
SubList stored in ArrayList: [Justin, Ajeet, John]
SubList stored in List: [Justin, Ajeet, John]
注意：
如果指定的索引超出了ArrayList的范围（fromIndex > 0 || toIndex < size），则subList方法抛出IndexOutOfBoundsException。
IllegalArgumentException - 如果起始索引大于终点索引（fromIndex < toIndex）。
JavaArrayList lastIndexOf(Object Obj)方法
原文： https://beginnersbook.com/2013/12/java-arraylist-lastindexofobject-0bj-method-example/
方法lastIndexOf(Object obj)返回ArrayList中指定元素的最后一次出现的索引。如果列表中不存在指定的元素，则返回 -1。
public int lastIndexOf(Object obj)
这将返回ArrayList中元素Obj的最后一次出现的索引。
例
在下面的示例中，我们有一个Integer ArrayList，它具有很少的重复元素。我们使用lastIndexof 方法获取少数元素的最后一个索引。
package beginnersbook.com;
import java.util.ArrayList;
public class LastIndexOfExample {
public static void main(String args[]) {
//ArrayList of Integer Type
ArrayList<Integer> al = new ArrayList<Integer>();
al.add(1);
al.add(88);
al.add(9);
al.add(17);
al.add(17);
al.add(9);
al.add(17);
al.add(91);
al.add(27);
al.add(1);
al.add(17);
System.out.println("Last occurrence of element 1: "+al.lastIndexOf(1));
System.out.println("Last occurrence of element 9: "+al.lastIndexOf(9));
System.out.println("Last occurrence of element 17: "+al.lastIndexOf(17));
System.out.println("Last occurrence of element 91: "+al.lastIndexOf(91));
System.out.println("Last occurrence of element 88: "+al.lastIndexOf(88));
}
}
输出：
Last occurrence of element 1: 9
Last occurrence of element 9: 5
Last occurrence of element 17: 10
Last occurrence of element 91: 7
Last occurrence of element 88: 1
Java ArrayList get()方法
原文： https://beginnersbook.com/2013/12/java-arraylist-get-method-example/
ArrayList get(int index)方法用于从列表中获取元素。我们需要在调用get方法时指定索引，并返回指定索引处的值。
public Element get(int index)
如果索引小于零或大于列表的大小（索引< 0或索引>=列表的大小），则此方法抛出IndexOutOfBoundsException。
例
在下面的例子中，我们通过使用get方法获得了一些arraylist的元素。
package beginnersbook.com;
import java.util.ArrayList;
public class GetMethodExample {
public static void main(String[] args) {
ArrayList<String> al = new ArrayList<String>();
al.add("pen");
al.add("pencil");
al.add("ink");
al.add("notebook");
al.add("book");
al.add("books");
al.add("paper");
al.add("white board");
System.out.println("First element of the ArrayList: "+al.get(0));
System.out.println("Third element of the ArrayList: "+al.get(2));
System.out.println("Sixth element of the ArrayList: "+al.get(5));
System.out.println("Fourth element of the ArrayList: "+al.get(3));
}
}
输出：
First element of the ArrayList: pen
Third element of the ArrayList: ink
Sixth element of the ArrayList: books
Fourth element of the ArrayList: notebook
参考：
Java ArrayList indexOf()方法
原文： https://beginnersbook.com/2013/12/java-arraylist-indexof-method-example/
ArrayList类方法indexOf(Object o)用于查找列表中特定元素的索引。
public int indexOf(Object o)
如果列表中不存在指定的元素，则此方法返回 -1。
例
package beginnersbook.com;
import java.util.ArrayList;
public class IndexOfExample {
public static void main(String[] args) {
ArrayList<String> al = new ArrayList<String>();
al.add("AB");
al.add("CD");
al.add("EF");
al.add("GH");
al.add("IJ");
al.add("KL");
al.add("MN");
System.out.println("Index of 'AB': "+al.indexOf("AB"));
System.out.println("Index of 'KL': "+al.indexOf("KL"));
System.out.println("Index of 'AA': "+al.indexOf("AA"));
System.out.println("Index of 'EF': "+al.indexOf("EF"));
}
}
输出：
Index of 'AB': 0
Index of 'KL': 5
Index of 'AA': -1
Index of 'EF': 2
参考：
Java ArrayList contains()方法
原文： https://beginnersbook.com/2013/12/java-arraylist-contains-method-example/
ArrayList contains()方法用于检查给定列表中指定的元素是否存在。
public boolean contains(Object element)
如果在列表中找到指定的元素，则返回true，否则返回false。
例
在这个例子中，我们有两个ArrayList（ArrayList<String>和ArrayList<Integer>），我们正在检查两个列表中是否存在少量元素。
package beginnersbook.com;
import java.util.ArrayList;
public class ContainsExample {
public static void main(String[] args) {
ArrayList<String> al = new ArrayList<String>();
al.add("pen");
al.add("pencil");
al.add("ink");
al.add("notebook");
System.out.println("ArrayList contains the string 'ink pen': "
+al.contains("ink pen"));
System.out.println("ArrayList contains the string 'pen': "
+al.contains("pen"));
System.out.println("ArrayList contains the string 'pencil': "
+al.contains("pencil"));
System.out.println("ArrayList contains the string 'book': "
+al.contains("book"));
ArrayList<Integer> al2 = new ArrayList<Integer>();
al2.add(1);
al2.add(99);
al2.add(56);
al2.add(13);
al2.add(44);
al2.add(6);
System.out.println("'1' is present in arraylist: "+al2.contains(1));
System.out.println("'55' is present in arraylist: "+al2.contains(55));
System.out.println("'44' is there in arraylist: "+al2.contains(44));
System.out.println("'7' is there in arraylist: "+al2.contains(7));
}
}
输出：
ArrayList contains the string 'ink pen': false
ArrayList contains the string 'pen': true
ArrayList contains the string 'pencil': true
ArrayList contains the string 'book': false
'1' is present in arraylist: true
'55' is present in arraylist: false
'44' is there in arraylist: true
'7' is there in arraylist: false
参考：
关于ArrayList的其他教程
如何在 Java 中比较两个ArrayList
原文： https://beginnersbook.com/2013/12/how-to-compare-two-arraylist-in-java/
在本教程中，我们将学习如何比较两个ArrayList。我们将使用contains()方法来比较不同ArrayList的两个元素。
public boolean contains(Object o)
如果列表包含Object，则返回true，否则返回false。
示例：
在这个例子中，我们有两个String类型的ArrayList，al1和al2。我们使用contains()方法比较了这些ArrayList，并将比较结果存储在第三个ArrayList（al3和al4）中。
package beginnersbook.com;
import java.util.ArrayList;
public class Details
{
public static void main(String [] args)
{
ArrayList<String> al1= new ArrayList<String>();
al1.add("hi");
al1.add("How are you");
al1.add("Good Morning");
al1.add("bye");
al1.add("Good night");
ArrayList<String> al2= new ArrayList<String>();
al2.add("Howdy");
al2.add("Good Evening");
al2.add("bye");
al2.add("Good night");
//Storing the comparison output in ArrayList<String>
ArrayList<String> al3= new ArrayList<String>();
for (String temp : al1)
al3.add(al2.contains(temp) ? "Yes" : "No");
System.out.println(al3);
//Storing the comparison output in ArrayList<Integer>
ArrayList<Integer> al4= new ArrayList<Integer>();
for (String temp2 : al1)
al4.add(al2.contains(temp2) ? 1 : 0);
System.out.println(al4);
}
}
输出：
[No, No, No, Yes, Yes]
[0, 0, 0, 1, 1]
上面代码中的逻辑是什么？
如果al2中存在ArrayList al1的第一个元素，那么ArrayList``al3将具有"Yes"而al4将具有 1 但是如果该元素不存在则将在al3中存储"No"，在al4中存储 0。
如何在 java 中同步ArrayList
原文： https://beginnersbook.com/2013/12/how-to-synchronize-arraylist-in-java-with-example/
当我们在Vector vs ArrayList 上共享教程时，我们已经讨论了一些关于同步的问题。我们知道ArrayList是非同步的，不应在没有显式同步的多线程环境中使用。这篇文章将讨论如何在 Java 中同步ArrayList。
显式同步有两种方法：
- 使用
Collections.synchronizedList()方法 - 使用
ArrayList的线程安全变体：CopyOnWriteArrayList
示例 1：用于同步ArrayList的Collections.synchronizedList()方法
在这个例子中，我们使用 Collections.synchronizedList()方法。这里要注意的重点是迭代器应该在这种类型的同步中处于同步块中，如下例所示。
package beginnersbook.com;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Collections;
public class Details {
public static void main(String a[]){
List<String> syncal =
Collections.synchronizedList(new ArrayList<String>());
//Adding elements to synchronized ArrayList
syncal.add("Pen");
syncal.add("NoteBook");
syncal.add("Ink");
System.out.println("Iterating synchronized ArrayList:");
synchronized(syncal) {
Iterator<String> iterator = syncal.iterator();
while (iterator.hasNext())
System.out.println(iterator.next());
}
}
}
输出：
Iterating synchronized ArrayList:
Pen
NoteBook
Ink
方法 2：使用CopyOnWriteArrayList
CopyOnWriteArrayList 是ArrayList的线程安全变体。
package beginnersbook.com;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.Iterator;
public class Details {
public static void main(String a[]){
CopyOnWriteArrayList<String> al = new CopyOnWriteArrayList<String>();
//Adding elements to synchronized ArrayList
al.add("Pen");
al.add("NoteBook");
al.add("Ink");
System.out.println("Displaying synchronized ArrayList Elements:");
//Synchronized block is not required in this method
Iterator<String> iterator = al.iterator();
while (iterator.hasNext())
System.out.println(iterator.next());
}
}
输出：
Displaying synchronized ArrayList Elements:
Pen
NoteBook
Ink
ArrayList
如何交换ArrayList中的两个元素
原文： https://beginnersbook.com/2013/12/how-to-swap-two-elements-in-an-arraylist/
本教程将帮助您了解如何在ArrayList中交换两个元素。我们使用[Collections.swap()](https://docs.oracle.com/javase/7/docs/api/java/util/Collections.html#swap(java.util.List, int, int))方法进行交换。
public static void swap(List list, int i1, int i2)
该方法将索引i1的元素与索引i2的元素交换。它抛出IndexOutOfBoundsException - 如果i1或i2小于零或大于列表的大小（i1 < 0 || i1 >= list.size() || i2 < 0 || i2 >= list.size()）。
在ArrayList中交换两个元素的示例
在这个例子中，我们有一个ArrayList<String>我们使用Collections.swap()方法交换ArrayList的第二个（index = 1）和第五个（index = 4）元素。
package beginnersbook.com;
import java.util.ArrayList;
import java.util.Collections;
public class SwappingExample {
public static void main(String a[]){
ArrayList<String> al = new ArrayList<String>();
al.add("Sachin");
al.add("Rahul");
al.add("Saurav");
al.add("Sunil");
al.add("Kapil");
al.add("Vinod");
System.out.println("ArrayList before Swap:");
for(String temp: al){
System.out.println(temp);
}
//Swapping 2nd(index 1) element with the 5th(index 4) element
Collections.swap(al, 1, 4);
System.out.println("ArrayList after swap:");
for(String temp: al){
System.out.println(temp);
}
}
}
输出：
ArrayList before Swap:
Sachin
Rahul
Saurav
Sunil
Kapil
Vinod
ArrayList after swap:
Sachin
Kapil
Saurav
Sunil
Rahul
Vinod
如何在 Java 中覆盖ArrayList的toString方法
原文： https://beginnersbook.com/2013/12/how-to-override-tostring-method-for-arraylist-in-java/
当我们处理对象的ArrayList时，必须覆盖toString()方法以获得所需格式的输出。在本教程中，我们将了解如何在 Java 中覆盖ArrayList的toString()方法。
示例：
我们这里有两个类Student和Demo。Student只有两个属性学生姓名和学生年龄。正如您所看到的，我们已经在Student类本身中重写了toString()方法。在Demo类中，我们将学生对象存储在ArrayList 中，然后我们使用高级for循环迭代ArrayList。您可以很好地看到输出采用我们在toString()中指定的格式。您可以根据需要提供toString()编码。
package beginnersbook.com;
public class Student
{
private String studentname;
private int studentage;
Student(String name, int age)
{
this.studentname=name;
this.studentage=age;
}
@Override
public String toString() {
return "Name is: "+this.studentname+" & Age is: "+this.studentage;
}
}
另一个类：
package beginnersbook.com;
import java.util.ArrayList;
public class Demo
{
public static void main(String [] args)
{
ArrayList<Student> al= new ArrayList<Student>();
al.add(new Student("Chaitanya", 26));
al.add(new Student("Ajeet", 25));
al.add(new Student("Steve", 55));
al.add(new Student("Mary", 18));
al.add(new Student("Dawn", 22));
for (Student tmp: al){
System.out.println(tmp);
}
}
}
输出：
Name is: Chaitanya & Age is: 26
Name is: Ajeet & Age is: 25
Name is: Steve & Age is: 55
Name is: Mary & Age is: 18
Name is: Dawn & Age is: 22
如果我们不会覆盖toString()，我们将得到以下格式的输出：
不覆盖toString()时上述程序的输出：
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
如何在 java 中序列化ArrayList
原文： https://beginnersbook.com/2013/12/how-to-serialize-arraylist-in-java/
ArrayList 是默认可序列化的。这意味着您无需显式实现Serializable接口以序列化ArrayList。在本教程中，我们将学习如何序列化和反序列化ArrayList。
例：
序列化：运行下面的类，它将创建一个文件myfile，它将以字节流的形式具有ArrayList对象。我们将在接收器端使用myfile从字节流重新创建Object。 注意：我们没有在下面的类中实现Serializable接口，因为默认情况下ArrayList已经被序列化了。
package beginnersbook.com;
import java.util.ArrayList;
import java.io.*;
public class ArrayListSerialization
{
public static void main(String [] args)
{
ArrayList<String> al=new ArrayList<String>();
al.add("Hello");
al.add("Hi");
al.add("Howdy");
try{
FileOutputStream fos= new FileOutputStream("myfile");
ObjectOutputStream oos= new ObjectOutputStream(fos);
oos.writeObject(al);
oos.close();
fos.close();
}catch(IOException ioe){
ioe.printStackTrace();
}
}
}
反序列化：
在这个类中，我们从myfile中检索字节流，我们使用上面的类存储了这些字节流。我们将返回的对象类型转换为ArrayList并显示ArrayList的元素。观察输出：我们获得了在序列化之前添加到ArrayList的相同元素。
package beginnersbook.com;
import java.io.*;
import java.util.ArrayList;
public class DeSerializationClass
{
public static void main(String [] args)
{
ArrayList<String> arraylist= new ArrayList<String>();
try
{
FileInputStream fis = new FileInputStream("myfile");
ObjectInputStream ois = new ObjectInputStream(fis);
arraylist = (ArrayList) ois.readObject();
ois.close();
fis.close();
}catch(IOException ioe){
ioe.printStackTrace();
return;
}catch(ClassNotFoundException c){
System.out.println("Class not found");
c.printStackTrace();
return;
}
for(String tmp: arraylist){
System.out.println(tmp);
}
}
}
输出：
Hello
Hi
Howdy
这就是ArrayList的序列化主题的全部内容。如果你有任何问题，请让我知道。
如何在 java 中连接/组合两个ArrayList
原文： https://beginnersbook.com/2013/12/how-to-joincombine-two-arraylists-in-java/
在本教程中，我们将了解如何在 Java 中连接（或组合）两个ArrayList。我们将使用addAll()方法在最后一个ArrayList中连接两个 ArrayLists。
示例：
在这个例子中，我们将两个ArrayList合并在一个ArrayList中，然后显示最终List的元素。
package beginnersbook.com;
import java.util.ArrayList;
public class Details
{
public static void main(String [] args)
{
//First ArrayList
ArrayList<String> arraylist1=new ArrayList<String>();
arraylist1.add("AL1: E1");
arraylist1.add("AL1: E2");
arraylist1.add("AL1: E3");
//Second ArrayList
ArrayList<String> arraylist2=new ArrayList<String>();
arraylist2.add("AL2: E1");
arraylist2.add("AL2: E2");
arraylist2.add("AL2: E3");
//New ArrayList
ArrayList<String> al= new ArrayList<String>();
al.addAll(arraylist1);
al.addAll(arraylist2);
//Displaying elements of the joined ArrayList
for(String temp: al){
System.out.println(temp);
}
}
}
输出：
AL1: E1
AL1: E2
AL1: E3
AL2: E1
AL2: E2
AL2: E3
如何将ArrayList克隆到另一个ArrayList
原文： https://beginnersbook.com/2013/12/how-to-clone-an-arraylist-to-another-arraylist/
在本教程中，我们将学习如何将ArrayList克隆到另一个。我们将使用ArrayList类的clone()方法来实现我们的目的。
Object clone()
此方法返回ArrayList实例的浅表副本。
ArrayList克隆的完整示例
在这个例子中，我们有一个String类型的ArrayList，我们使用clone()方法将它克隆到另一个ArrayList。这里有趣的一点是，当我们在clone()方法之后添加并删除了原始ArrayList中的一些元素时，克隆的ArrayList没有受到影响。它表明clone()方法只返回ArrayList的浅表副本。
package beginnersbook.com;
import java.util.ArrayList;
public class Details {
public static void main(String a[]){
ArrayList<String> al = new ArrayList<String>();
//Adding elements to the ArrayList
al.add("Apple");
al.add("Orange");
al.add("Mango");
al.add("Grapes");
System.out.println("ArrayList: "+al);
ArrayList<String> al2 = (ArrayList<String>)al.clone();
System.out.println("Shallow copy of ArrayList: "+ al2);
//add and remove on original ArrayList
al.add("Fig");
al.remove("Orange");
//Display of both ArrayLists after add & remove
System.out.println("Original ArrayList:"+al);
System.out.println("Cloned ArrayList:"+al2);
}
}
输出：
ArrayList: [Apple, Orange, Mango, Grapes]
Shallow copy of ArrayList: [Apple, Orange, Mango, Grapes]
Original ArrayList:[Apple, Mango, Grapes, Fig]
Cloned ArrayList:[Apple, Orange, Mango, Grapes]
如何在 Java 中清空ArrayList
原文： https://beginnersbook.com/2013/12/how-to-empty-an-arraylist-in-java/
有两种方法可以清空ArrayList - 使用 ArrayList.clear()方法或借助 ArrayList.removeAll()方法。尽管两种方法都执行相同的任务，但它们清空List的方式却截然不同。
让我们先看下面的例子，然后我们将看到clear()和removeAll()之间的实现和区别。
package beginnersbook.com;
import java.util.ArrayList;
import java.io.*;
public class Details
{
public static void main(String [] args)
{
ArrayList<String> al1=new ArrayList<String>();
al1.add("abc");
al1.add("xyz");
System.out.println("ArrayList before clear: "+al1);
al1.clear();
System.out.println("ArrayList after clear: "+al1);
ArrayList<String> al2=new ArrayList<String>();
al2.add("text 1");
al2.add("text 2");
System.out.println("ArrayList before removeAll: "+al2);
al2.removeAll(al2);
System.out.println("ArrayList before removeAll: "+al2);
}
}
输出：
ArrayList before clear: [abc, xyz]
ArrayList after clear: []
ArrayList before removeAll: [text 1="text" 2="2" language="1,"][/text]
ArrayList before removeAll: []
因为你们两个方法都可以完成相同的工作，所以它们会清空ArrayList。是时候确定哪种方法可以提供良好的性能。
clear()方法的实际代码：
public void clear() {
for (int i = 0; i < size; i++)
arraylist[i] = null;
size = 0;
}
这里arraylist是ArrayList类的一个实例。
代码removeAll()方法：
public boolean removeAll(Collection c) {
boolean ismodified = false;
Iterator iterator = iterator();
while (iterator.hasNext()) {
if (c.contains(iterator.next())) {
iterator.remove();
ismodified = true;
}
}
return ismodified;
}
通过查看这两种方法的代码，我们可以很好地说，与removeAll()方法相比，clear()方法提供了更好的性能。
clear的性能：O(n)
removeAll的性能：O(n^2)
Java ArrayList isEmpty()方法
原文： https://beginnersbook.com/2013/12/java-arraylist-isempty-method-example/
java.util.ArrayList类的isEmpty()方法用于检查列表是否为空。此方法返回一个布尔值。
public boolean isEmpty()
如果列表为空则返回true，否则返回false。
例
package beginnersbook.com;
import java.util.ArrayList;
public class IsEmptyExample {
public static void main(String args[]) {
//ArrayList of Integer Type
ArrayList<Integer> al = new ArrayList<Integer>();
//Checking whether the list is empty
System.out.println("Is ArrayList Empty: "+al.isEmpty());
//Adding Integer elements
al.add(1);
al.add(88);
al.add(9);
al.add(17);
//Again checking for isEmpty
System.out.println("Is ArrayList Empty: "+al.isEmpty());
//Displaying elements of the list
for (Integer num: al) {
System.out.println(num);
}
}
}
输出：
Is ArrayList Empty: true
Is ArrayList Empty: false
1
88
9
17
Java ArrayList trimToSize()方法
原文： https://beginnersbook.com/2013/12/java-arraylist-trimtosize-method-example/
trimToSize() 方法用于内存优化。它将ArrayList的容量调整为当前列表大小。对于例如arraylist的容量为 15，但其中只有 5 个元素，在此ArrayList上调用trimToSize()方法会将容量从 15 更改为 5。
public void trimToSize()
例
在这里，我定义了容量为 50 的ArrayList。在添加了 10 个元素之后，我调用了trimToSize()方法，该方法将容量从 50 减少到 10（arraylist的当前大小）。
package beginnersbook.com;
import java.util.ArrayList;
public class TrimExample {
public static void main(String args[]) {
ArrayList<Integer> arraylist = new ArrayList<Integer>(50);
arraylist.add(1);
arraylist.add(2);
arraylist.add(3);
arraylist.add(4);
arraylist.add(5);
arraylist.add(6);
arraylist.add(7);
arraylist.add(1);
arraylist.add(1);
arraylist.add(1);
arraylist.trimToSize();
System.out.println(arraylist);
}
}
输出：
[1, 2, 3, 4, 5, 6, 7, 1, 1, 1]
Java ArrayList set()方法
原文： https://beginnersbook.com/2013/12/java-arraylist-set-method-example/
如果需要根据索引更新列表元素，则可以使用ArrayList类的set方法。方法set(int index, Element E)使用给定元素E更新指定索引的元素。
public E set(int index, Element E)
例：
在这个例子中，我有一个Integer类型的ArrayList，其中我添加了几个元素，然后我使用java.util.ArrayList类的set方法更新了一些元素。
package beginnersbook.com;
import java.util.ArrayList;
public class SetExample {
public static void main(String args[]) {
ArrayList<Integer> arraylist = new ArrayList<Integer>();
arraylist.add(1);
arraylist.add(2);
arraylist.add(3);
arraylist.add(4);
arraylist.add(5);
arraylist.add(6);
arraylist.add(7);
System.out.println("ArrayList before update: "+arraylist);
//Updating 1st element
arraylist.set(0, 11);
//Updating 2nd element
arraylist.set(1, 22);
//Updating 3rd element
arraylist.set(2, 33);
//Updating 4th element
arraylist.set(3, 44);
//Updating 5th element
arraylist.set(4, 55);
System.out.println("ArrayList after Update: "+arraylist);
}
}
输出：
ArrayList before update: [1, 2, 3, 4, 5, 6, 7]
ArrayList after Update: [11, 22, 33, 44, 55, 6, 7]
Java ArrayList ensureCapacity()方法
原文： https://beginnersbook.com/2013/12/java-arraylist-ensurecapacity-method-example/
ArrayList内部实现了可扩展的动态数组，这意味着它可以自动增加和减小其大小。如果我们尝试将一个元素添加到已经完整的ArrayList中，那么它会在内部自动重新调整大小以适应新元素，但有时这不是一个好方法。
考虑需要向已经完整的ArrayList添加大量元素的情况，在这种情况下，ArrayList必须调整大小数次，这将导致性能不佳。对于这种情况，Java.util.ArrayList类的ensureCapacity()方法非常有用，因为它将ArrayList的大小增加了指定的容量。
public void ensureCapacity(int minCapacity)
例
package beginnersbook.com;
import java.util.ArrayList;
public class EnsureCapacityExample {
public static void main(String args[]) {
// ArrayList with Capacity 4
ArrayList<String> al = new ArrayList<String>(4);
//Added 4 elements
al.add("Hi");
al.add("Hello");
al.add("Bye");
al.add("GM");
//Increase capacity to 5
al.ensureCapacity(5);
al.add("GE");
// let us print all the elements available in list
for (String temp: al) {
System.out.println(temp);
}
}
}
输出：
Hi
Hello
Bye
GM
GE
ArrayList基础知识
ArrayList转换
如何在 java 中将ArrayList转换为字符串数组
原文： https://beginnersbook.com/2013/12/how-to-convert-arraylist-to-string-array-in-java/
在这篇文章中，我们共享了两种转换ArrayList<String>到String数组的方法。
方法 1：使用ArrayList get()方法手动转换
这是将所有ArrayList<String>元素复制到String Array[]的手动方式。在这个例子中，我们通过三个步骤将整个列表复制到数组中 a）首先我们使用size()方法获得ArrayList大小 b）使用get()方法获取列表的每个元素，最后 c）将每个元素分配给相应的数组元素使用赋值运算符=。
package beginnersbook.com;
import java.util.*;
public class ArrayListTOArray {
public static void main(String[] args) {
/*ArrayList declaration and initialization*/
ArrayList<String> arrlist= new ArrayList<String>();
arrlist.add("String1");
arrlist.add("String2");
arrlist.add("String3");
arrlist.add("String4");
/*ArrayList to Array Conversion */
String array[] = new String[arrlist.size()];
for(int j =0;j<arrlist.size();j++){
array[j] = arrlist.get(j);
}
/*Displaying Array elements*/
for(String k: array)
{
System.out.println(k);
}
}
}
输出：
String1
String2
String3
String4
方法 2：使用toArray()方法进行转换
在上面的例子中，我们手动将ArrayList的每个元素复制到数组中。但是有一个方法toArray()可以将字符串类型的ArrayList转换为字符串数组。更多关于toArray()的信息。
package beginnersbook.com;
import java.util.*;
public class Example {
public static void main(String[] args) {
/*ArrayList declaration and initialization*/
ArrayList<String> friendsnames= new ArrayList<String>();
friendsnames.add("Ankur");
friendsnames.add("Ajeet");
friendsnames.add("Harsh");
friendsnames.add("John");
/*ArrayList to Array Conversion */
String frnames[]=friendsnames.toArray(new String[friendsnames.size()]);
/*Displaying Array elements*/
for(String k: frnames)
{
System.out.println(k);
}
}
}
输出：
Ankur
Ajeet
Harsh
John
如何在 java 中将数组转换为ArrayList
原文： https://beginnersbook.com/2013/12/how-to-convert-array-to-arraylist-in-java/
在上一个教程中，我们共享了两个使用示例将ArrayList转换为数组的方法。这里我们分享三种不同的方式将数组转换为ArrayList。基本上我们将String数组转换为String类型的ArrayList。
String array[] to ArrayList<String>
方法 1：使用Arrays.asList()进行转换
句法：
ArrayList<T> arraylist = new ArrayList<T>(Arrays.asList(arrayname));
例：
在这个例子中，我们使用Arrays.asList方法将Array转换为ArrayList。
import java.util.*;
public class ArrayToArrayList {
public static void main(String[] args) {
/* Array Declaration and initialization*/
String citynames[]={"Agra", "Mysore", "Chandigarh", "Bhopal"};
/*Array to ArrayList conversion*/
ArrayList<String> citylist= new ArrayList<String>(Arrays.asList(citynames));
/*Adding new elements to the converted List*/
citylist.add("New City2");
citylist.add("New City3");
/*Final ArrayList content display using for*/
for (String str: citylist)
{
System.out.println(str);
}
}
}
输出：
Agra
Mysore
Chandigarh
Bhopal
New City2
New City3
方法 2：Collections.addAll方法
Collections.addAll方法将所有数组元素添加到指定的集合中。这就是调用Collections.addAll方法的方法。它与Arrays.asList方法的作用相同，但它比它快得多，因此性能方面这是将数组转换为ArrayList的最佳方法。
String array[]={new Item(1), new Item(2), new Item(3), new Item(4)};
ArrayList<T> arraylist = new ArrayList<T>();
Collections.addAll(arraylist, array);
或
Collections.addAll(arraylist, new Item(1), new Item(2), new Item(3), new Item(4));
实现示例
import java.util.*;
public class Example2 {
public static void main(String[] args) {
/* Array Declaration and initialization*/
String array[]={"Hi", "Hello", "Howdy", "Bye"};
/*ArrayList declaration*/
ArrayList<String> arraylist= new ArrayList<String>();
/*Conversion*/
Collections.addAll(arraylist, array);
/*Adding new elements to the converted List*/
arraylist.add("String1");
arraylist.add("String2");
/*Display array list*/
for (String str: arraylist)
{
System.out.println(str);
}
}
}
结果：
Hi
Hello
Howdy
Bye
String1
String2
方法 3：手动方式
我们还可以手动将所有数组元素添加到ArrayList中。下面的示例显示了手动转换的逻辑。
package beginnersbook.com;
import java.util.*;
public class Details {
public static void main(String[] args) {
/*ArrayList declaration*/
ArrayList<String> arraylist= new ArrayList<String>();
/*Initialized Array*/
String array[] = {"Text1","Text2","Text3","Text4"};
/*array.length returns the current number of
* elements present in array*/
for(int i =0;i<array.length;i++)
{
/* We are adding each array's element to the ArrayList*/
arraylist.add(array[i]);
}
/*ArrayList content*/
for(String str: arraylist)
{
System.out.println(str);
}
}
}
输出：
Text1
Text2
Text3
Text4
差异
java 中ArrayList和Vector之间的区别
原文： https://beginnersbook.com/2013/12/difference-between-arraylist-and-vector-in-java/
ArrayList和Vector 都在内部使用数组作为数据结构。但是，它们存储和处理数据的方式几乎没有差异。在这篇文章中，我们将讨论ArrayList和Vector之间的差异和相似之处。
ArrayList Vs Vector：
1）同步：ArrayList是非同步的，这意味着多个线程可以同时在ArrayList上工作。对于例如如果一个线程正在对ArrayList执行添加操作，则可能有另一个线程在多线程环境中同时对ArrayList执行删除操作
Vector同步。这意味着如果一个线程正在处理Vector，则没有其他线程可以获取它。与ArrayList不同，一次只有一个线程可以对向量执行操作。
2）调整大小：ArrayList和Vector都可以动态增长和缩小以保持存储的最佳使用，但是它们调整大小的方式是不同的。调整大小时，ArrayList的大小增加一半，而增长时，Vector默认大小增加一倍。
3）性能：ArrayList提供更好的性能，因为它是非同步的。向量操作性能较差，因为它们是线程安全的，在Vector上工作的线程会对其进行锁定，这使得其他线程等待直到锁定被释放。
4）快速失败：首先让我解释什么是快速失败：如果集合（ArrayList，vector等）通过任何方式进行结构修改，除了添加或删除方法，在创建迭代器后，迭代器将抛出ConcurrentModificationException。结构修改是指从集合中添加或删除元素。
根据Vector javadoc，Vector返回的迭代器不是快速失败的。另一方面，ArrayList返回的iterator和listIterator是快速失败的。
5）谁真的属于集合框架？ 该向量不是集合框架的一部分，它已被包含在集合中。它可以被视为旧版代码。Vector没有任何List集合不能做的内容。因此应避免使用Vector。如果需要线程安全操作，则使ArrayList同步，如本文下一节所述，或者使用CopyOnWriteArrayList，它是ArrayList的线程安全变体。
这些类之间的相似性很少，如下所示：
Vector和ArrayList都使用可扩展的数组数据结构。- 这些类（
Vector和ArrayList）返回的迭代器和listIterator是快速失败的。 - 它们都是有序的集合类，因为它们维护元素的插入顺序。
- 向量和
ArrayList都允许重复和空值。 - 当溢出和删除发生时，它们会自动增长和缩小。
何时使用ArrayList以及何时使用Vector？
这完全取决于要求。如果需要执行“线程安全”操作，则向量是最好的选择，因为它确保一次只有一个线程访问集合。
性能：同步操作比非同步操作消耗更多时间，因此如果不需要线程安全操作，ArrayList是更好的选择，因为并发进程会提高性能。
如何使ArrayList同步？
如上所述，ArrayList方法是非同步的，但如果有需要，你可以让它们像这样同步 -
//Use Collecions.synzhonizedList method
List list = Collections.synchronizedList(new ArrayList());
...
//If you wanna use iterator on the synchronized list, use it
//like this. It should be in synchronized block.
synchronized (list) {
Iterator iterator = list.iterator();
while (iterator.hasNext())
...
iterator.next();
...
}
参考：
Java 中ArrayList和HashMap的区别
原文： https://beginnersbook.com/2013/12/difference-between-arraylist-and-hashmap-in-java/
ArrayList 和 HashMap 是 Java 中常用的两个集合类。尽管两者都是集合框架的一部分，但它们存储和处理数据的方式却完全不同。在这篇文章中，我们将看到这两个集合之间的主要区别。
Java 中的ArrayList与HashMap
1）实现：ArrayList实现List接口，而HashMap是Map接口的实现。List和Map是两个完全不同的集合接口。
2）内存消耗：ArrayList单独存储元素的值，并在内部维护每个元素的索引。
ArrayList<String> arraylist = new ArrayList<String>();
//String value is stored in array list
arraylist.add("Test String");
HashMap存储键值对。对于每个值，必须在HashMap中关联一个键。这清楚地表明，与ArrayList相比，HashMap中的内存消耗很高。
HashMap<Integer, String> hmap= new HashMap<Integer, String>();
//String value stored along with the key value in hash map
hmap.put(123, "Test String");
3） 顺序 ：ArrayList维护插入顺序，而HashMap则没有。这意味着ArrayList以与插入列表相同的顺序返回列表项。另一方面，HashMap不维护任何顺序，返回的键值对不按任何顺序排序。
4）重复：ArrayList允许重复元素，但HashMap不允许重复键（它允许重复值）。
5） 空值 ：ArrayList可以包含任意数量的null元素。HashMap允许一个空键和任意数量的空值。
6） get方法：在ArrayList中我们可以通过指定它的索引得到元素。在HashMap中，通过指定相应的键来获取元素。
参考：
Java 中ArrayList和LinkedList的区别
原文： https://beginnersbook.com/2013/12/difference-between-arraylist-and-linkedlist-in-java/
ArrayList和LinkedList都实现了List接口，它们的方法和结果几乎相同。然而，它们之间几乎没有差异，这取决于要求，使一个优于另一个。
ArrayList与LinkedList
1）搜索：与LinkedList搜索操作相比，ArrayList搜索操作非常快。ArrayList中的get(int index)给出O(1)的性能，而LinkedList性能为O(n)。
原因：ArrayList维护其元素的基于索引的系统，因为它隐式使用数组数据结构，这使得搜索列表中的元素更快。另一方面，LinkedList实现了双向链表，它需要遍历所有元素来搜索元素。
2）删除：LinkedList删除操作给出O(1)性能，而ArrayList提供可变性能：在最坏的情况下O(n)（删除第一个元素）和在最好的情况下O(1)（删除最后一个元素）。
结论：与ArrayList相比，LinkedList元素删除更快。
原因：LinkedList的每个元素都维护着两个指针（地址），这些指针指向列表中的两个邻居元素。因此，移除仅需要改变将要移除的节点的两个相邻节点（元素）中的指针位置。在ArrayList中，需要移动所有元素以填充由要移除的元素创建的空间。
3）插入性能：LinkedList add方法给出O(1)性能，而ArrayList在最坏情况下给出O(n)。原因与删除说明相同。
4）内存开销：ArrayList维护索引和元素数据，而LinkedList维护元素数据和相邻节点的两个指针，因此LinkedList中的内存消耗比较高。
这些类之间的相似性很少，如下所示：
ArrayList和LinkedList都是List接口的实现。- 它们都维护元素的插入顺序，这意味着在显示
ArrayList和LinkedList元素时，结果集将具有将元素插入List的相同顺序。 - 这两个类都是非同步的，可以使用
Collections.synchronizedList方法显式同步。 - 这些类返回的迭代器和
listIterator是快速失败的（如果在创建迭代器之后的任何时候对列表进行结构修改，除非通过迭代器自己的remove或add方法，迭代器将抛出ConcurrentModificationException）。
何时使用LinkedList以及何时使用ArrayList？
1）如上所述，与 ArrayList（O(n)）相比，insertList和remove操作在LinkedList中提供了良好的性能（O(1)）。因此，如果在应用中需要频繁添加和删除，则LinkedList是最佳选择。
2）搜索（get方法）操作在Arraylist（O(1)）中很快但在LinkedList（O(n)中）没有，因此如果添加和删除操作较少且搜索操作要求较多，则ArrayList将是您最好的选择。
参考：
链表
LinkedList基础知识
Java 中的LinkedList
原文： https://beginnersbook.com/2013/12/linkedlist-in-java-with-example/
与 Java 中的数组类似，LinkedList是线性数据结构。但是，LinkedList元素不存储在像数组这样的连续位置中，它们使用指针相互链接。LinkedList的每个元素都具有指向LinkedList的下一个元素的引用（地址/指针）。
目录
- LinkedList 表示
- 为什么我们需要一个链表？
- Java 中 LinkedList 类的层次结构
- Java 链表添加元素的例子
- Java 链表示例删除元素
- Java 中的 LinkedList 示例
- LinkedList 类的方法
- 关于 LinkedList 的教程 ] - LinkedList 类的所有方法都在单独的教程中详细介绍
LinkedList表示
LinkedList中的每个元素称为节点。LinkedList的每个节点包含两个项目：1）元素的内容 2）指向链表中的下一节点的指针/地址/引用。
这就是LinkedList的样子：
注意：
LinkedList的头仅包含List的第一个元素的地址。LinkedList的最后一个元素在节点的指针部分包含null，因为它是List的结尾，因此它不指向任何内容，如上图所示。- 上图所示的图表示单链表。
LinkedList的另一种复杂类型变体称为双向链表，双向链表的节点包含三部分：1）指向链表的前一节点的指针，2）元素的内容，3）指向链表的下一个节点的指针。
为什么我们需要链表？
你必须知道数组也是一个线性数据结构，但**数组有一些限制，如：
1）数组的大小是固定的**这是我们决定的创建一个数组，因此很难预先预测元素的数量，如果声明的大小不足，那么我们就不能增加数组的大小，如果我们声明一个大型数组并且不需要存储那么多的元素那么它是浪费记忆。
2）数组元素需要连续的存储单元来存储它们的值。
3）在数组中插入一个元素是性能上昂贵的，因为我们必须移动几个元素来为新元素腾出空间。例如：
假设我们有一个具有以下元素的数组：10,12,15,20,4,5,100，现在如果我们想要在具有值 12 的元素之后插入新元素 99 那么我们必须将 12 之后的所有元素移到右边，为新元素腾出空间。
类似地，从数组中删除元素也是性能上昂贵的操作，因为删除元素之后的所有元素都必须向左移位。
通过提供以下功能在链表中处理这些限制：
-
链表允许动态内存分配，这意味着内存分配在运行时由编译器完成在链表声明中我们不需要提及列表的大小。
-
链表元素不需要连续的存储单元，因为元素使用包含列表的下一个节点的地址的节点的引用部分相互链接。
-
在链表中插入和删除操作的性能并不昂贵，因为从链表中添加和删除元素不需要元素移位，只需要更改前一个节点和下一个节点的指针。
Java 中的LinkedList类的层次结构
Java LinkedList添加元素的示例
在下面的例子中，我们使用add()，addFirst()和addLast()方法在LinkedList中的所需位置添加元素，LinkedList类中有几个这样有用的方法，我在本文末尾提到过文章。
package com.beginnersbook;
import java.util.*;
public class JavaExample{
public static void main(String args[]){
LinkedList<String> list=new LinkedList<String>();
//Adding elements to the Linked list
list.add("Steve");
list.add("Carl");
list.add("Raj");
//Adding an element to the first position
list.addFirst("Negan");
//Adding an element to the last position
list.addLast("Rick");
//Adding an element to the 3rd position
list.add(2, "Glenn");
//Iterating LinkedList
Iterator<String> iterator=list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
输出：
从LinkedList中删除元素的 Java 示例
在下面的示例中，我们将检查LinkedList中用于从LinkedList中的某些位置删除元素的几个流行的删除方法。这些方法的详细说明以及示例将在单独的教程中介绍，本文末尾提供了链接。
package com.beginnersbook;
import java.util.*;
public class JavaExample{
public static void main(String args[]){
LinkedList<String> list=new LinkedList<String>();
//Adding elements to the Linked list
list.add("Steve");
list.add("Carl");
list.add("Raj");
list.add("Negan");
list.add("Rick");
//Removing First element
//Same as list.remove(0);
list.removeFirst();
//Removing Last element
list.removeLast();
//Iterating LinkedList
Iterator<String> iterator=list.iterator();
while(iterator.hasNext()){
System.out.print(iterator.next()+" ");
}
//removing 2nd element, index starts with 0
list.remove(1);
System.out.print("\nAfter removing second element: ");
//Iterating LinkedList again
Iterator<String> iterator2=list.iterator();
while(iterator2.hasNext()){
System.out.print(iterator2.next()+" ");
}
}
}
输出：
Java 中的LinkedList示例
import java.util.*;
public class LinkedListExample {
public static void main(String args[]) {
/* Linked List Declaration */
LinkedList<String> linkedlist = new LinkedList<String>();
/*add(String Element) is used for adding
* the elements to the linked list*/
linkedlist.add("Item1");
linkedlist.add("Item5");
linkedlist.add("Item3");
linkedlist.add("Item6");
linkedlist.add("Item2");
/*Display Linked List Content*/
System.out.println("Linked List Content: " +linkedlist);
/*Add First and Last Element*/
linkedlist.addFirst("First Item");
linkedlist.addLast("Last Item");
System.out.println("LinkedList Content after addition: " +linkedlist);
/*This is how to get and set Values*/
Object firstvar = linkedlist.get(0);
System.out.println("First element: " +firstvar);
linkedlist.set(0, "Changed first item");
Object firstvar2 = linkedlist.get(0);
System.out.println("First element after update by set method: " +firstvar2);
/*Remove first and last element*/
linkedlist.removeFirst();
linkedlist.removeLast();
System.out.println("LinkedList after deletion of first and last element: " +linkedlist);
/* Add to a Position and remove from a position*/
linkedlist.add(0, "Newly added item");
linkedlist.remove(2);
System.out.println("Final Content: " +linkedlist);
}
}
输出：
Linked List Content: [Item1, Item5, Item3, Item6, Item2]
LinkedList Content after addition: [First Item, Item1, Item5, Item3, Item6, Item2, Last Item]
First element: First Item
First element after update by set method: Changed first item
LinkedList after deletion of first and last element: [Item1, Item5, Item3, Item6, Item2]
Final Content: [Newly added item, Item1, Item3, Item6, Item2]
LinkedList类的方法：
这里我已经提到了
LinkedList方法的简要说明，我已经在单独的教程中介绍了这些方法中的每一个，本文末尾提供了链接。
对于以下方法中的所有示例，请将llistobj视为LinkedList<String>的参考。
LinkedList<String> llistobj = new LinkedList<String>();
1） boolean add(Object item)：它在列表的末尾添加项目。
llistobj.add("Hello");
它会在链表的末尾添加字符串"Hello"。
2） void add(int index, Object item)：它在列表的给定索引处添加一个项目。
llistobj.add(2, "bye");
这将在第 3 个位置添加字符串"bye"（索引 2 是第 3 个位置，因为索引从 0 开始）。
3） boolean addAll(Collection c)：它将指定集合c的所有元素添加到列表中。如果指定的集合为null，则抛出NullPointerException。考虑下面的例子 -
LinkedList<String> llistobj = new LinkedList<String>();
ArrayList<String> arraylist= new ArrayList<String>();
arraylist.add("String1");
arraylist.add("String2");
llistobj.addAll(arraylist);
这段代码会将ArrayList的所有元素添加到LinkedList中。
4）boolean addAll(int index, Collection c)：它将集合c的所有元素从列表中的给定索引开始添加到列表中。如果集合c为null，则抛出NullPointerException;如果指定的索引超出范围，则抛出IndexOutOfBoundsException。
llistobj.add(5, arraylist);
它会将ArrayList的所有元素从位置 6（索引 5）开始添加到LinkedList。
5）void addFirst(Object item)：它在列表的第一个位置添加项（或元素）。
llistobj.addFirst("text");
它会在列表的开头添加字符串"text"。
6）void addLast(Object item)：它在列表的末尾插入指定的项目。
llistobj.addLast("Chaitanya");
该语句将在链表的末尾添加一个字符串"Chaitanya"。
7） void clear()：删除列表中的所有元素。
llistobj.clear();
8）Object clone()：返回列表的副本。
对于例如我的linkedList有四个项目：text1，text2，text3和text4。
Object str= llistobj.clone();
System.out.println(str);
输出：上面代码的输出是：
[text1，text2，text3，text4]
9） boolean contains(Object item)：它检查给定项是否存在于列表中。如果该项目存在，则返回true，否则返回false。
boolean var = llistobj.contains("TestString");
它将检查列表中是否存在字符串"TestString"。
10） Object get(int index)：从列表中返回指定索引的项。
Object var = llistobj.get(2);
它将从列表中获取第 3 个项目。
11） Object getFirst()：从列表中取出第一个项目。
Object var = llistobj.getFirst();
12）Object getLast()：从列表中取出最后一项。
Object var= llistobj.getLast();
13）int indexOf(Object item)：返回指定项的索引。
llistobj.indexOf("bye");
14）int lastIndexOf(Object item)：返回指定元素最后一次出现的索引。
int pos = llistobj.lastIndexOf("hello);
整数变量pos将具有最后一次出现的字符串"hello"的索引。
15）Object poll()：它返回并删除列表的第一项。
Object o = llistobj.poll();
16）Object pollFirst()：与poll()方法相同。删除列表中的第一项。
Object o = llistobj.pollFirst();
17）Object pollLast()：返回并删除列表的最后一个元素。
Object o = llistobj.pollLast();
18）Object remove()：删除列表的第一个元素。
llistobj.remove();
19）Object remove(int index)：它从列表中删除指定索引处的项目。
llistobj.remove(4);
它将从列表中删除第 5 个元素。
20）Object remove(Object obj)：从列表中删除指定的对象。
llistobj.remove("Test Item");
21）Object removeFirst()：它从列表中删除第一个项目。
llistobj.removeFirst();
22）Object removeLast()：删除列表的最后一项。
llistobj.removeLast();
23）Object removeFirstOccurrence(Object item)：删除指定项的第一次出现。
llistobj.removeFirstOccurrence("text");
它将从列表中删除第一次出现的字符串"text"。
24）Object removeLastOccurrence(Object item)：删除给定元素的最后一次出现。
llistobj.removeLastOccurrence("String1);
它将删除最后一次出现的字符串"String1"。
25）Object set(int index, Object item)：用赋值更新指定索引的项。
llistobj.set(2, "Test");
它将使用字符串"Test"更新第 3 个元素。
26） int size()：返回列表元素的数量。
llistobj.size();
LinkedList教程
以下是我在LinkedList上分享的教程。
LinkedList基础知识
添加/删除
- 向
LinkedList添加元素 - 在
LinkedList中的特定索引处添加元素 - 在
LinkedList的开头和结尾添加元素 - 在
LinkedList的前面添加一个元素 - 从
LinkedList中删除第一个和最后一个元素 - 从特定索引中删除元素
- 从
LinkedList中删除指定的元素 - 从
LinkedList中删除所有元素 - 将
List的所有元素附加到LinkedList
获取/搜索
Iterator/ListIterator
其他教程
- 用新值替换
LinkedList中的元素 - 检查
LinkedList中是否存在特定元素 - 将
LinkedList克隆到另一个LinkedList - 获取
LinkedList中元素的最后一次出现的索引 LinkedList push()和pop()方法LinkedList poll()，pollFirst()和pollLast()方法LinkedList peek()，peekFirst()和peekLast()方法
转换
差异
参考
java 中的ArrayList - 集合框架
Arraylist类实现List接口，它基于Array数据结构。由于其提供的功能和灵活性，它被广泛使用。大多数开发人员选择Arraylist而不是数组，因为它是传统 java 数组的一个很好的替代品。ArrayList是List接口的可调整大小的数组实现。它实现了所有可选的列表操作，并允许所有元素，包括null。
为什么ArrayList比数组好？
数组的限制是它有一个固定的长度，所以如果它已满，你不能再添加任何元素，同样如果有多个元素被删除，内存消耗将与它不收缩相同。
另一个ArrayList可以在添加和删除元素后动态增长和缩小（参见下图）。除了这些好处之外，ArrayList类还允许我们使用它的预定义方法，这使我们的任务变得简单。让我们看一下图表来理解从ArrayList中添加和删除元素，然后我们将看到这些程序。
在指定位置的ArrayList中添加元素：
从ArrayList中删除元素：
本指南末尾有一些关于
ArrayList的教程列表，请参考它以完全理解和学习ArrayList概念。
如何创建ArrayList？
我们可以通过编写一个这样的简单语句来创建一个ArrayList：
此语句创建一个名为alist且类型为String的ArrayList。该类型确定列表将具有哪种类型的元素。由于此列表是String类型，因此要添加到此列表的元素将为String类型。
ArrayList<String> alist=new ArrayList<String>();
类似地，我们可以创建接受int元素的ArrayList。
ArrayList<Integer> list=new ArrayList<Integer>();
如何将元素添加到ArrayList？
我们使用add()方法向ArrayList添加元素，这种方法有几种变体，我们可以根据需要使用它们。例如：如果我们想在List的末尾添加元素，那么就这样做：
alist.add("Steve"); //This will add "Steve" at the end of List
要在ArrayList中的指定位置添加元素，我们可以在add方法中指定索引，如下所示：
alist.add(3, "Steve"); //This will add "Steve" at the fourth position
让我们写完整的代码：
import java.util.*;
class JavaExample{
public static void main(String args[]){
ArrayList<String> alist=new ArrayList<String>();
alist.add("Steve");
alist.add("Tim");
alist.add("Lucy");
alist.add("Pat");
alist.add("Angela");
alist.add("Tom");
//displaying elements
System.out.println(alist);
//Adding "Steve" at the fourth position
alist.add(3, "Steve");
//displaying elements
System.out.println(alist);
}
}
输出：
[Steve, Tim, Lucy, Pat, Angela, Tom]
[Steve, Tim, Lucy, Steve, Pat, Angela, Tom]
注意：由于索引从 0 开始，索引 3 将代表第四个位置而不是 3。
如何从ArrayList中删除元素？
我们使用remove()方法从ArrayList中删除元素，与add()方法相同，此方法也有一些变化。
例如：
import java.util.*;
class JavaExample{
public static void main(String args[]){
ArrayList<String> alist=new ArrayList<String>();
alist.add("Steve");
alist.add("Tim");
alist.add("Lucy");
alist.add("Pat");
alist.add("Angela");
alist.add("Tom");
//displaying elements
System.out.println(alist);
//Removing "Steve" and "Angela"
alist.remove("Steve");
alist.remove("Angela");
//displaying elements
System.out.println(alist);
//Removing 3rd element
alist.remove(2);
//displaying elements
System.out.println(alist);
}
}
输出：
[Steve, Tim, Lucy, Pat, Angela, Tom]
[Tim, Lucy, Pat, Tom]
[Tim, Lucy, Tom]
迭代ArrayList
在上面的例子中，我们只是通过引用ArrayList实例来显示ArrayList元素，这绝对不是显示元素的正确方法。显示元素的正确方法是使用像这样的高级for循环。
import java.util.*;
class JavaExample{
public static void main(String args[]){
ArrayList<String> alist=new ArrayList<String>();
alist.add("Gregor Clegane");
alist.add("Khal Drogo");
alist.add("Cersei Lannister");
alist.add("Sandor Clegane");
alist.add("Tyrion Lannister");
//iterating ArrayList
for(String str:alist)
System.out.println(str);
}
}
输出：
Gregor Clegane
Khal Drogo
Cersei Lannister
Sandor Clegane
Tyrion Lannister
Java 中的ArrayList示例
此示例演示如何从ArrayList创建，初始化，添加和删除元素。在这个例子中，我们有一个类型为String的ArrayList。我们使用add(String E)方法在ArrayList中添加了 5 个String元素，此方法在ArrayList的末尾添加了元素。
然后我们使用方法add(int index，String E)在ArrayList中添加另外两个元素，此方法在指定的索引处添加指定的元素，索引 0 表示第一个位置，1 表示第二个位置。
然后我们从ArrayList中删除元素"Chaitanya"和"Harry"，然后我们使用方法remove(int index)删除ArrayList的第二个元素。由于我们已将索引指定为 1（remove(1)），因此它将删除第二个元素。
import java.util.*;
public class JavaExample {
public static void main(String args[]) {
/* Creating ArrayList of type "String" which means
* we can only add "String" elements
*/
ArrayList<String> obj = new ArrayList<String>();
/*This is how we add elements to an ArrayList*/
obj.add("Ajeet");
obj.add("Harry");
obj.add("Chaitanya");
obj.add("Steve");
obj.add("Anuj");
// Displaying elements
System.out.println("Original ArrayList:");
for(String str:obj)
System.out.println(str);
/* Add element at the given index
* obj.add(0, "Rahul") - Adding element "Rahul" at first position
* obj.add(1, "Justin") - Adding element "Justin" at second position
*/
obj.add(0, "Rahul");
obj.add(1, "Justin");
// Displaying elements
System.out.println("ArrayList after add operation:");
for(String str:obj)
System.out.println(str);
//Remove elements from ArrayList like this
obj.remove("Chaitanya"); //Removes "Chaitanya" from ArrayList
obj.remove("Harry"); //Removes "Harry" from ArrayList
// Displaying elements
System.out.println("ArrayList after remove operation:");
for(String str:obj)
System.out.println(str);
//Remove element from the specified index
obj.remove(1); //Removes Second element from the List
// Displaying elements
System.out.println("Final ArrayList:");
for(String str:obj)
System.out.println(str);
}
}
输出：
Original ArrayList:
Ajeet
Harry
Chaitanya
Steve
Anuj
ArrayList after add operation:
Rahul
Justin
Ajeet
Harry
Chaitanya
Steve
Anuj
ArrayList after remove operation:
Rahul
Justin
Ajeet
Steve
Anuj
Final ArrayList:
Rahul
Ajeet
Steve
Anuj
ArrayList类的方法
在上面的例子中，我们使用了add()和remove()等方法。但是有许多方法可以直接使用ArrayList类的对象。我们来讨论一下ArrayList类的几个重要方法。
1）add(Object o)：此方法向arraylist添加一个对象o。
obj.add("hello");
这个语句会在最后一个位置的arraylist中添加一个字符串hello。
2） add(int index, Object o)：它将对象o添加到给定索引处的ArrayList中。
obj.add(2, "bye");
它将字符串再见添加到ArrayList的第二个索引（ArrayList以索引 0 开头的第三个位置）。
3）remove(Object o)：从ArrayList中删除对象o。
obj.remove("Chaitanya");
该语句将从ArrayList中删除字符串"Chaitanya"。
4）remove(int index)：从给定索引中删除元素。
obj.remove(3);
它将删除索引 3 的元素（列表的第 4 个元素 - 列表以 0 开头）。
5）set(int index, Object o)：用于更新元素。它用对象o替换指定索引处的元素。
obj.set(2, "Tom");
它将使用值Tom替换第 3 个元素（index = 2是第 3 个元素）。
6）int indexOf(Object o)：给出对象o的索引。如果在列表中找不到该元素，则此方法返回值 -1。
int pos = obj.indexOf("Tom");
这将给出列表中字符串Tom的索引（位置）。
7）Object get(int index)：返回列表对象，该对象出现在指定的索引处。
String str= obj.get(2);
函数get将返回存储在第 3 个位置（索引 2）的字符串，并将分配给字符串"str"。我们已将返回的值存储在字符串变量中，因为在我们的示例中，我们已经定义了ArrayList是String类型。如果您有整数ArrayList，则返回的值应存储在整数变量中。
8）int size()：它给出了ArrayList的大小 - 列表元素的数量。
int numberofitems = obj.size();
9）boolean contains(Object o)：它检查给定对象o是否存在于ArrayList中，如果它在那里则返回true，否则返回false。
obj.contains("Steve");
如果字符串"Steve"出现在列表中，它将返回true，否则我们将得到false。
10）clear()：**它用于一次性删除ArrayList的所有元素。下面的代码将删除其对象为obj的ArrayList的所有元素。
obj.clear();
Java ArrayList教程
以下是 beginnersbook.com 上发布的ArrayList教程列表。
ArrayList基础知识
排序
添加/删除
- 将元素添加到
ArrayList - 在
ArrayList的特定索引处添加元素 - 将
Collection元素追加到ArrayList - 将所有列表元素复制到
ArrayList - 将所有集合元素插入
ArrayList中的指定位置 - 从
ArrayList中的指定索引中删除元素 - 从
ArrayList中删除指定的元素
获取/搜索
关于ArrayList的其他教程
- 比较两个
ArrayList - 同步
ArrayList - 在
ArrayList中交换两个元素 - 覆盖
toString()方法 -ArrayList - 序列化
ArrayList - 连接两个
ArrayList - 克隆
ArrayList到另一个ArrayList - 使
ArrayList为空 - 检查
ArrayList是否为空 - 修剪
ArrayList的大小 - 替换
ArrayList中现有元素的值 - 增加
ArrayList的容量（大小）
转换：
区别：
参考
如何在 Java 中遍历LinkedList
原文： https://beginnersbook.com/2013/12/how-to-loop-linkedlist-in-java/
在上一个教程中，我们通过示例讨论了LinkedList及其方法。在这里，我们将看到如何循环/迭代LinkedList。可以通过四种方式迭代LinkedList -
for循环- 高级
For循环 - 迭代器
while循环
示例：
在这个例子中，我们有一个String类型的LinkedList，我们使用所有四个提到的方法循环它。
package beginnersbook.com;
import java.util.*;
public class LinkedListExample {
public static void main(String args[]) {
/*LinkedList declaration*/
LinkedList<String> linkedlist=new LinkedList<String>();
linkedlist.add("Apple");
linkedlist.add("Orange");
linkedlist.add("Mango");
/*for loop*/
System.out.println("**For loop**");
for(int num=0; num<linkedlist.size(); num++)
{
System.out.println(linkedlist.get(num));
}
/*Advanced for loop*/
System.out.println("**Advanced For loop**");
for(String str: linkedlist)
{
System.out.println(str);
}
/*Using Iterator*/
System.out.println("**Iterator**");
Iterator i = linkedlist.iterator();
while (i.hasNext()) {
System.out.println(i.next());
}
/* Using While Loop*/
System.out.println("**While Loop**");
int num = 0;
while (linkedlist.size() > num) {
System.out.println(linkedlist.get(num));
num++;
}
}
}
输出：
**For loop**
Apple
Orange
Mango
**Advanced For loop**
Apple
Orange
Mango
**Iterator**
Apple
Orange
Mango
**While Loop**
Apple
Orange
Mango
LinkedList添加/删除
使用add(E e)方法向LinkedList添加元素
原文： https://beginnersbook.com/2014/08/adding-an-element-to-linkedlist-using-adde-e-method-java/
描述
使用LinkedList类的add(E e)方法向LinkedList添加新元素的程序。
示例
import java.util.LinkedList;
class LinkedListAdd {
public static void main(String[] args) {
// create a LinkedList
LinkedList<String> list = new LinkedList<String>();
// Adding elements to the LinkedList
list.add("Harry");
list.add("Ajeet");
list.add("Tom");
list.add("Steve");
// Displaying LinkedList elements
System.out.println("LinkedList elements: "+list);
// Adding another element
list.add("Kate");
// Displaying LinkedList elements after add(E e)
System.out.println("LinkedList elements: "+list);
}
}
输出：
LinkedList elements: [Harry, Ajeet, Tom, Steve]
LinkedList elements: [Harry, Ajeet, Tom, Steve, Kate]
LinkedList.add(E e)方法
public boolean add(E e)：将指定的元素追加到此列表的末尾。
此方法相当于addLast(E)。更多内容： Java LinkedList.add(E e)
Java - 在LinkedList的特定索引处添加元素
原文： https://beginnersbook.com/2014/07/java-add-element-at-specific-index-in-linkedlist-example/
在本教程中，我们将学习如何在LinkedList 中的特定索引处添加新元素。我们将使用LinkedList类的add(int index, Element E)方法来执行此操作。
有关此方法的更多信息，请参见 javadoc ：
public void add(int index, E element)：将指定元素插入此列表中的指定位置。将当前位置的元素（如果有）和任何后续元素向右移动（将其添加到其索引中）。
示例
在这个例子中，我们有一个LinkedList<String>，我们使用add()方法将一个元素添加到它的第五个位置（第四个索引）。完整的代码如下：
import java.util.LinkedList;
import java.util.Iterator;
public class AddElement {
public static void main(String[] args) {
// Create a LinkedList
LinkedList<String> linkedlist = new LinkedList<String>();
// Add elements to LinkedList
linkedlist.add("Delhi");
linkedlist.add("Agra");
linkedlist.add("Mysore");
linkedlist.add("Chennai");
linkedlist.add("Pune");
// Adding new Element at 5th Position
linkedlist.add(4, "NEW ELEMENT");
// Iterating the list in forward direction
System.out.println("LinkedList elements After Addition:");
Iterator it= linkedlist.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
输出：
LinkedList elements After Addition:
Delhi
Agra
Mysore
Chennai
NEW ELEMENT
Pune
Java - 在LinkedList的开头和结尾添加元素
原文： https://beginnersbook.com/2014/07/java-add-elements-at-beginning-and-end-of-linkedlist-example/
示例
在这个例子中，我们将学习如何在LinkedList的开头和结尾添加元素。我们将使用LinkedList类的addFirst()和addLast()方法。方法定义和描述如下：
1）public void addFirst(E e)：在此列表的开头插入指定的元素。
2）public void addLast(E e)：将指定的元素追加到此列表的末尾。
完整代码：
import java.util.LinkedList;
public class AddExample {
public static void main(String[] args) {
// Creating LinkedList of String Elements
LinkedList<String> linkedlist = new LinkedList<String>();
//Populating it with String values
linkedlist.add("AA");
linkedlist.add("BB");
linkedlist.add("CC");
linkedlist.add("DD");
linkedlist.add("EE");
//Displaying LinkedList elements
System.out.println(linkedlist);
//Adding an element at the beginning
linkedlist.addFirst("FIRST");
//Displaying the List after addition
System.out.println(linkedlist);
//Adding an element at the end of list
linkedlist.addLast("LAST");
//Displaying the final list
System.out.println(linkedlist);
}
}
输出：
[AA, BB, CC, DD, EE]
[FIRST, AA, BB, CC, DD, EE]
[FIRST, AA, BB, CC, DD, EE, LAST]
在 Java 中将LinkedList添加到LinkedList的前面
原文： https://beginnersbook.com/2014/08/adding-element-to-front-of-linkedlist-in-java/
描述
将元素添加到链表的开始（头部）的程序。
程序
import java.util.LinkedList;
class LinkedListExample {
public static void main(String[] args) {
// create a LinkedList
LinkedList<String> list = new LinkedList<String>();
// Add elements
list.add("AA");
list.add("BB");
list.add("CC");
list.add("DD");
// Display List element
System.out.println("LinkedList Elements:"+list);
// Adding element to front of LinkedList
/* public boolean offerFirst(E e): Inserts the
* specified element at the front of this list.
*/
list.offerFirst("NEW Element");
// Displaying List after adding element
System.out.println("LinkedList After Addition:"+list);
}
}
输出：
LinkedList Elements:[AA, BB, CC, DD]
LinkedList After Addition:[NEW Element, AA, BB, CC, DD]
Java - 从LinkedList删除第一个和最后一个元素
原文： https://beginnersbook.com/2014/07/java-remove-first-and-last-element-from-linkedlist-example/
在本教程中，我们将学习如何从LinkedList中删除第一个和最后一个元素。在最后几篇文章中，我们分享了以下教程：
示例
我们使用removeFirst()方法删除第一个和removeLast()方法以从LinkedList中删除最后一个元素。方法定义和描述如下：
1）public E removeFirst()：从此列表中删除并返回第一个元素。
2）public E removeLast()：删除并返回此列表中的最后一个元素。
完整代码：
import java.util.LinkedList;
public class RemoveExample {
public static void main(String[] args) {
// Create a LinkedList
LinkedList<String> linkedlist = new LinkedList<String>();
// Add elements to LinkedList
linkedlist.add("Item1");
linkedlist.add("Item2");
linkedlist.add("Item3");
linkedlist.add("Item4");
linkedlist.add("Item5");
// Displaying Elements before remove
System.out.println("LinkedList Elements are:");
for(String str: linkedlist){
System.out.println(str);
}
// Removing First element
Object firstElement = linkedlist.removeFirst();
System.out.println("\nElement removed: "+ firstElement);
// Removing last Element
Object lastElement = linkedlist.removeLast();
System.out.println("Element removed: "+ lastElement);
// LinkedList elements after remove
System.out.println("\nList Elements after Remove:");
for(String str2: linkedlist){
System.out.println(str2);
}
}
}
输出：
LinkedList Elements are:
Item1
Item2
Item3
Item4
Item5
Element removed: Item1
Element removed: Item5
List Elements after Remove:
Item2
Item3
Item4
Java - 从LinkedList的特定索引删除元素
原文： https://beginnersbook.com/2014/07/java-remove-element-from-a-specific-index-in-linkedlist-example/
在这个例子中，我们将看到如何从LinkedList中删除一个元素。
示例
我们将使用LinkedList类的remove(int index)方法从特定索引中删除元素。方法定义和描述如下：
public E remove(int index)：删除此列表中指定位置的元素。将任何后续元素向左移位（从索引中减去一个）。返回从列表中删除的元素。
import java.util.LinkedList;
public class RemoveFromLinkedList {
public static void main(String[] args) {
// Create a LinkedList
LinkedList<String> linkedlist = new LinkedList<String>();
// Add elements to LinkedList
linkedlist.add("Cobol");
linkedlist.add("JCL");
linkedlist.add("C++");
linkedlist.add("C#");
linkedlist.add("Java");
// Displaying Elements before replace
System.out.println("LinkedList Elements:");
for(String str: linkedlist){
System.out.println(str);
}
// Removing 3rd element
Object e1 = linkedlist.remove(2);
System.out.println("\nElement "+ e1+ " removed from the list\n");
// LinkedList elements after remove
System.out.println("After removal:");
for(String str2: linkedlist){
System.out.println(str2);
}
}
}
输出：
LinkedList Elements:
Cobol
JCL
C++
C#
Java
Element C++ removed from the list
After removal:
Cobol
JCL
C#
Java
Java - 从LinkedList删除特定元素
原文： https://beginnersbook.com/2014/07/java-remove-specific-elements-from-linkedlist-example/
在上一篇文章中，我们在上分享了如何从LinkedList中的特定索引中删除元素的教程。在这里，我们将学习如何从LinkedList中删除特定元素。
示例
我们将使用remove(Object o)方法来执行此删除。有关此方法的更多信息如下：
public boolean remove(Object o)：从该列表中删除指定元素的第一个匹配项（如果存在）。如果此列表不包含该元素，则不会更改。如果此列表包含指定的元素，则返回true（或等效地，如果此列表因调用而更改）。
import java.util.LinkedList;
public class RemoveExample {
public static void main(String[] args) {
// Create a LinkedList
LinkedList<String> linkedlist = new LinkedList<String>();
// Add elements to LinkedList
linkedlist.add("Item1");
linkedlist.add("Item2");
linkedlist.add("Item3");
linkedlist.add("Item4");
linkedlist.add("Item5");
// Displaying Elements before remove
System.out.println("Before Remove:");
for(String str: linkedlist){
System.out.println(str);
}
// Removing "Item4" from the list
linkedlist.remove("Item4");
// LinkedList elements after remove
System.out.println("\nAfter Remove:");
for(String str2: linkedlist){
System.out.println(str2);
}
}
}
输出：
Before Remove:
Item1
Item2
Item3
Item4
Item5
After Remove:
Item1
Item2
Item3
Item5
Java - 从LinkedList删除所有元素
原文： https://beginnersbook.com/2014/07/java-remove-all-elements-from-linkedlist-example/
在这个例子中，我们将看到如何从LinkedList中删除所有元素。我们将使用LinkedList类的clear()方法来做到这一点。方法定义和描述如下：
public void clear()：删除此列表中的所有元素。此调用返回后，列表将为空。
示例
在这个例子中，我们有一个String类型的LinkedList，它有 5 个元素。我们调用clear()方法并在调用clear()方法之前和之后显示LinkedList元素。
import java.util.LinkedList;
public class RemoveAllExample {
public static void main(String[] args) {
// Create a LinkedList
LinkedList<String> linkedlist = new LinkedList<String>();
// Add elements to LinkedList
linkedlist.add("Item1");
linkedlist.add("Item2");
linkedlist.add("Item3");
linkedlist.add("Item4");
linkedlist.add("Item5");
// Displaying Elements before remove
System.out.println("Before clear():");
for(String str: linkedlist){
System.out.println(str);
}
// Removing all the elements from LinkedList
linkedlist.clear();
// LinkedList elements after remove
System.out.println("After clear():");
for(String str2: linkedlist){
System.out.println(str2);
}
}
}
输出：
Before clear():
Item1
Item2
Item3
Item4
Item5
After clear():
如何初始化ArrayList
原文： https://beginnersbook.com/2013/12/how-to-initialize-an-arraylist/
在上一篇文章中，我们讨论了 Java 中的类ArrayList，它是重要的方法。在这里，我们分享了多种使用示例初始化ArrayList的方法。
方法 1：使用Arrays.asList进行初始化
语法：
ArrayList<Type> obj = new ArrayList<Type>(
Arrays.asList(Object o1, Object o2, Object o3, ....so on));
示例：
import java.util.*;
public class InitializationExample1 {
public static void main(String args[]) {
ArrayList<String> obj = new ArrayList<String>(
Arrays.asList("Pratap", "Peter", "Harsh"));
System.out.println("Elements are:"+obj);
}
}
输出：
Elements are:[Pratap, Peter, Harsh]
方法 2：初始化ArrayList的匿名内部类方法
Syntax:
ArrayList<T> obj = new ArrayList<T>(){{
add(Object o1);
add(Object o2);
add(Object o3);
...
...
}};
示例：
import java.util.*;
public class InitializationExample2 {
public static void main(String args[]) {
ArrayList<String> cities = new ArrayList<String>(){{
add("Delhi");
add("Agra");
add("Chennai");
}};
System.out.println("Content of Array list cities:"+cities);
}
}
输出：
Content of Array list cities:[Delhi, Agra, Chennai]
方法 3：ArrayList初始化的正常方式
语法：
ArrayList<T> obj = new ArrayList<T>();
obj.add("Object o1");
obj.add("Object o2");
obj.add("Object o3");
...
...
示例：
import java.util.*;
public class Details {
public static void main(String args[]) {
ArrayList<String> books = new ArrayList<String>();
books.add("Java Book1");
books.add("Java Book2");
books.add("Java Book3");
System.out.println("Books stored in array list are: "+books);
}
}
输出：
Books stored in array list are: [Java Book1, Java Book2, Java Book3]
方法 4：使用Collections.ncopies
Collections.ncopies方法可以在我们需要为其所有元素初始化ArrayList时使用相同的值。语法：count是元素数，element是项目值。
ArrayList<T> obj = new ArrayList<T>(Collections.nCopies(count, element));
示例：
import java.util.*;
public class Details {
public static void main(String args[]) {
ArrayList<Integer> intlist = new ArrayList<Integer>(Collections.nCopies(10, 5));
System.out.println("ArrayList items: "+intlist);
}
}
输出：
ArrayList items: [5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
将List的所有元素附加到LinkedList
原文： https://beginnersbook.com/2014/08/append-all-the-elements-of-a-list-to-linkedlist-java/
描述
使用LinkedList类的addAll()方法将List的所有元素添加到LinkedList的程序。
示例
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
class LinkedListAddAll {
public static void main(String[] args) {
// create a LinkedList
LinkedList<String> list = new LinkedList<String>();
// Add elements to the LinkedList
list.add("AA");
list.add("BB");
list.add("CC");
list.add("DD");
// Displaying linked list before add
System.out.println("Before: LinkedList: " + list);
// create a new list having few elements
List<String> arrayList = new ArrayList<String>();
arrayList.add("Item1");
arrayList.add("Item2");
arrayList.add("Item3");
// Append the list elements to LinkedList
list.addAll(arrayList);
// Displaying the LinkedList after addAll
System.out.println("After: LinkedList: " + list);
}
}
输出：
Before: LinkedList: [AA, BB, CC, DD]
After: LinkedList: [AA, BB, CC, DD, Item1, Item2, Item3]
addAll()方法：
public boolean addAll(Collection<? extends E> c)：将指定集合中的所有元素按指定集合的迭代器返回的顺序附加到此列表的末尾。 来源：`addAll()方法 - Javadoc。
在链表中获取/搜索
Java - 从LinkedList获取第一个和最后一个元素
原文： https://beginnersbook.com/2014/07/java-get-first-and-last-elements-from-linkedlist-example/
在本教程中，我们将看到一个关于如何从LinkedList获取第一个和最后一个元素的示例。
示例
这里我们有一个String类型的LinkedList，我们使用LinkedList类的getFirst()和getLast()方法得到它的第一个和最后一个元素。方法定义和描述如下：
1）public E getFirst()：返回此列表中的第一个元素。
2）public E getLast()：返回此列表中的最后一个元素。
import java.util.LinkedList;
public class GetFirstAndLast {
public static void main(String[] args) {
// Create a LinkedList
LinkedList<String> linkedlist = new LinkedList<String>();
// Add elements to LinkedList
linkedlist.add("Item1");
linkedlist.add("Item2");
linkedlist.add("Item3");
linkedlist.add("Item4");
linkedlist.add("Item5");
linkedlist.add("Item6");
// Getting First element of the List
Object firstElement = linkedlist.getFirst();
System.out.println("First Element is: "+firstElement);
// Getting Last element of the List
Object lastElement = linkedlist.getLast();
System.out.println("Last Element is: "+lastElement);
}
}
输出：
First Element is: Item1
Last Element is: Item6
Java - 从LinkedList的特定索引获取元素
原文： https://beginnersbook.com/2014/07/java-get-element-from-specific-index-of-linkedlist-example/
在这个例子中，我们将看到如何使用get(int index)方法从LinkedList的特定索引中获取元素：
public E get(int index)：返回此列表中指定位置的元素。
import java.util.LinkedList;
public class GetElementExample {
public static void main(String[] args) {
// Creating LinkedList of String Elements
LinkedList<String> linkedlist = new LinkedList<String>();
// Populating it with String values
linkedlist.add("AA");
linkedlist.add("BB");
linkedlist.add("CC");
linkedlist.add("DD");
linkedlist.add("EE");
System.out.println("LinkedList Elements : ");
//get(i) returns element present at index i
for(int i=0; i < linkedlist.size(); i++){
System.out.println("Element at index "+i+" is: "+linkedlist.get(i));
}
}
}
输出：
LinkedList Elements :
Element at index 0 is: AA
Element at index 1 is: BB
Element at index 2 is: CC
Element at index 3 is: DD
Element at index 4 is: EE
Java - 在LinkedList中搜索元素
原文： https://beginnersbook.com/2014/07/java-search-elements-in-linkedlist-example/
在本教程中，我们将学习如何搜索LinkedList 中的元素。我们将使用以下两种方法来搜索元素。
public int indexOf(Object o)：返回此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1。
public int lastIndexOf(Object o)：返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1。
示例
这里我们有一个String元素的LinkedList，我们正在使用LinkedList类的indexOf()和lastIndexOf()方法搜索一个字符串。
import java.util.LinkedList;
public class SearchInLinkedList {
public static void main(String[] args) {
// Step1: Create a LinkedList
LinkedList<String> linkedlist = new LinkedList<String>();
// Step2: Add elements to LinkedList
linkedlist.add("Tim");
linkedlist.add("Rock");
linkedlist.add("Hulk");
linkedlist.add("Rock");
linkedlist.add("James");
linkedlist.add("Rock");
//Searching first occurrence of element
int firstIndex = linkedlist.indexOf("Rock");
System.out.println("First Occurrence: " + firstIndex);
//Searching last occurrence of element
int lastIndex = linkedlist.lastIndexOf("Rock");
System.out.println("Last Occurrence: " + lastIndex);
}
}
输出：
First Occurrence: 1
Last Occurrence: 5
参考：
Java - 从LinkedList获取子列表
原文： https://beginnersbook.com/2014/07/java-get-sub-list-from-linkedlist-example/
示例
在这个例子中，我们使用LinkedList类的subList(int startIndex, int endIndex)方法获取LinkedList的子列表。它返回指定索引startIndex（包括）和endIndex（不包括）之间的List。对子列表所做的任何更改都将反映在原始列表中（我们在下面的程序中通过从子列表中删除元素并在删除后显示原始列表来测试它）。
import java.util.LinkedList;
import java.util.Iterator;
import java.util.List;
public class SublistExample {
public static void main(String[] args) {
// Create a LinkedList
LinkedList<String> linkedlist = new LinkedList<String>();
// Add elements to LinkedList
linkedlist.add("Item1");
linkedlist.add("Item2");
linkedlist.add("Item3");
linkedlist.add("Item4");
linkedlist.add("Item5");
linkedlist.add("Item6");
linkedlist.add("Item7");
// Displaying LinkedList elements
System.out.println("LinkedList elements:");
Iterator it= linkedlist.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
// Obtaining Sublist from the LinkedList
List sublist = linkedlist.subList(2,5);
// Displaying SubList elements
System.out.println("\nSub List elements:");
Iterator subit= sublist.iterator();
while(subit.hasNext()){
System.out.println(subit.next());
}
/* Any changes made to Sub List will be reflected
* in the original List. Lets take this example - We
* are removing element "Item4" from sublist and it
* should be removed from original list too. Observe
* the Output of this part of the program.
*/
sublist.remove("Item4");
System.out.println("\nLinkedList elements After remove:");
Iterator it2= linkedlist.iterator();
while(it2.hasNext()){
System.out.println(it2.next());
}
}
}
输出：
LinkedList elements:
Item1
Item2
Item3
Item4
Item5
Item6
Item7
Sub List elements:
Item3
Item4
Item5
LinkedList elements After remove:
Item1
Item2
Item3
Item5
Item6
Item7
LinkedList Iterator / ListIterator
Java - LinkedList Iterator
原文： https://beginnersbook.com/2014/07/java-linkedlist-iterator-example/
在上一篇文章中，我们学习了如何使用ListIterator遍历链表。在这里，我们将学习如何使用Iterator迭代LinkedList。
示例
我们在以下计划中遵循的步骤是：
1）创建LinkedList
2）使用add(Element E)方法向其添加元素
3）通过调用iterator()方法获取迭代器
4）使用Iterator类的hasNext()和next()方法遍历列表。
import java.util.LinkedList;
import java.util.Iterator;
public class IteratorExample {
public static void main(String[] args) {
// Create a LinkedList
LinkedList<String> linkedlist = new LinkedList<String>();
// Add elements to LinkedList
linkedlist.add("Delhi");
linkedlist.add("Agra");
linkedlist.add("Mysore");
linkedlist.add("Chennai");
linkedlist.add("Pune");
// Obtaining Iterator
Iterator it = linkedlist.iterator();
// Iterating the list in forward direction
System.out.println("LinkedList elements:");
while(it.hasNext()){
System.out.println(it.next());
}
}
}
输出：
LinkedList elements:
Delhi
Agra
Mysore
Chennai
Pune
Java - LinkedList ListIterator
原文： https://beginnersbook.com/2014/07/java-linkedlist-listiterator-example/
在这个例子中，我们将看到如何使用ListIterator迭代LinkedList。使用Listterator，我们可以在两个方向（向前和向后）迭代列表。除了遍历之外，我们还可以在迭代期间修改列表，并获取迭代器在列表中的当前位置。在ListIterator javadoc 上阅读更多相关信息。
示例
这里我们有一个链接的字符串列表，我们使用ListIterator在两个方向上遍历它。
import java.util.LinkedList;
import java.util.ListIterator;
public class ListIteratorExample {
public static void main(String[] args) {
// Create a LinkedList
LinkedList<String> linkedlist = new LinkedList<String>();
// Add elements to LinkedList
linkedlist.add("Delhi");
linkedlist.add("Agra");
linkedlist.add("Mysore");
linkedlist.add("Chennai");
linkedlist.add("Pune");
// Obtaining ListIterator
ListIterator listIt = linkedlist.listIterator();
// Iterating the list in forward direction
System.out.println("Forward iteration:");
while(listIt.hasNext()){
System.out.println(listIt.next());
}
// Iterating the list in backward direction
System.out.println("\nBackward iteration:");
while(listIt.hasPrevious()){
System.out.println(listIt.previous());
}
}
}
输出：
Forward iteration:
Delhi
Agra
Mysore
Chennai
Pune
Backward iteration:
Pune
Chennai
Mysore
Agra
Delhi
以反向顺序迭代LinkedList
原文： https://beginnersbook.com/2014/08/iterate-a-linkedlist-in-reverse-sequential-order-java/
描述
使用 LinkedList 类的 descendingIterator（）方法以相反的顺序迭代链表的程序。
程序
import java.util.LinkedList;
import java.util.Iterator;
class LinkedListDemo {
public static void main(String[] args) {
// create a LinkedList
LinkedList<String> list = new LinkedList<String>();
// Adding elements to the LinkedList
list.add("Element1");
list.add("Element2");
list.add("Element3");
list.add("Element4");
// Displaying LinkedList elements
System.out.println("LinkedList elements: "+list);
/* public Iterator<E> descendingIterator(): Returns an
* iterator over the elements in this list in reverse
* sequential order. The elements will be returned in
* order from last (tail) to first (head).
*/
Iterator it = list.descendingIterator();
// Displaying list in reverse order
System.out.println("Elements in Reverse Order:");
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
输出：
LinkedList elements: [Element1, Element2, Element3, Element4]
Elements in Reverse Order:
Element4
Element3
Element2
Element1
如何在 Java 中遍历ArrayList
原文： https://beginnersbook.com/2013/12/how-to-loop-arraylist-in-java/
之前我们分享了ArrayList示例和如何在 Java 中初始化ArrayList。在这篇文章中，我们将分享如何在 Java 中迭代（循环）ArrayList。
循环ArrayList有四种方法：
for循环- 高级循环
while循环- 迭代器
让我们看看下面的例子 - 我已经使用了所有提到的方法来迭代列表。
import java.util.*;
public class LoopExample {
public static void main(String[] args) {
ArrayList<Integer> arrlist = new ArrayList<Integer>();
arrlist.add(14);
arrlist.add(7);
arrlist.add(39);
arrlist.add(40);
/* For Loop for iterating ArrayList */
System.out.println("For Loop");
for (int counter = 0; counter < arrlist.size(); counter++) {
System.out.println(arrlist.get(counter));
}
/* Advanced For Loop*/
System.out.println("Advanced For Loop");
for (Integer num : arrlist) {
System.out.println(num);
}
/* While Loop for iterating ArrayList*/
System.out.println("While Loop");
int count = 0;
while (arrlist.size() > count) {
System.out.println(arrlist.get(count));
count++;
}
/*Looping Array List using Iterator*/
System.out.println("Iterator");
Iterator iter = arrlist.iterator();
while (iter.hasNext()) {
System.out.println(iter.next());
}
}
}
输出：
For Loop
14
7
39
40
Advanced For Loop
14
7
39
40
While Loop
14
7
39
40
Iterator
14
7
39
40
在下面的评论部分，Govardhan 问了一个问题：他问，如何使用Enumeration迭代ArrayList。 Govardhan 这里是代码：
如何使用Enumeration接口迭代arraylist元素
import java.util.Enumeration;
import java.util.ArrayList;
import java.util.Collections;
public class EnumExample {
public static void main(String[] args) {
//create an ArrayList object
ArrayList<String> arrayList = new ArrayList<String>();
//Add elements to ArrayList
arrayList.add("C");
arrayList.add("C++");
arrayList.add("Java");
arrayList.add("DotNet");
arrayList.add("Perl");
// Get the Enumeration object
Enumeration<String> e = Collections.enumeration(arrayList);
// Enumerate through the ArrayList elements
System.out.println("ArrayList elements: ");
while(e.hasMoreElements())
System.out.println(e.nextElement());
}
}
输出：
ArrayList elements:
C
C++
Java
DotNet
Perl
LinkedList上的其他教程
Java - 替换LinkedList中的元素
原文： https://beginnersbook.com/2014/07/java-replace-element-in-a-linkedlist-example/
在上一篇文章中，我们分享了在LinkedList中搜索元素的教程。在这里，我们将看到如何使用元素的索引用LinkedList 中的新值替换现有元素值。
示例
我们在下面的程序中使用的方法是：
public E set(int index, E element)：用指定的元素替换此列表中指定位置的元素。
完整代码：
import java.util.LinkedList;
public class ReplaceInLinkedList {
public static void main(String[] args) {
// Create a LinkedList
LinkedList<String> linkedlist = new LinkedList<String>();
// Add elements to LinkedList
linkedlist.add("Cobol");
linkedlist.add("JCL");
linkedlist.add("C++");
linkedlist.add("C#");
linkedlist.add("Java");
// Displaying Elements before replace
System.out.println("Before Replace:");
for(String str: linkedlist){
System.out.println(str);
}
// Replacing 3rd Element with new value
linkedlist.set(2, "NEW VALUE");
System.out.println("\n3rd Element Replaced \n");
// Displaying Elements after replace
System.out.println("After Replace:");
for(String str2: linkedlist){
System.out.println(str2);
}
}
}
输出：
Before Replace:
Cobol
JCL
C++
C#
Java
3rd Element Replaced
After Replace:
Cobol
JCL
NEW VALUE
C#
Java
Java - 检查LinkedList中是否存在特定元素
原文： https://beginnersbook.com/2014/07/java-check-if-a-particular-element-exists-in-linkedlist-example/
在这个例子中，我们将看到如何使用contains()方法检查LinkedList中是否存在特定元素：
public boolean contains(Object o)：如果此列表包含指定的元素，则返回true。更正式地，当且仅当此列表包含至少一个元素e时才返回true（o == null? e == null: o.equals(e)）。
import java.util.LinkedList;
public class CheckLinkedList {
public static void main(String[] args) {
// Creating LinkedList of String Elements
LinkedList<String> linkedlist = new LinkedList<String>();
// Populating it with String values
linkedlist.add("AA");
linkedlist.add("BB");
linkedlist.add("CC");
linkedlist.add("DD");
linkedlist.add("EE");
// contains() method checks whether the element exists
if (linkedlist.contains("CC")) {
System.out.println("Element CC is present in List");
} else {
System.out.println("List doesn't have element CC");
}
//Checking for element FF
if (linkedlist.contains("FF")) {
System.out.println("Element FF is present in List");
} else {
System.out.println("List doesn't have element FF");
}
}
}
输出：
Element CC is present in List
List doesn't have element FF
在 Java 中克隆一个通用的LinkedList
原文： https://beginnersbook.com/2014/08/clone-a-generic-linkedlist-in-java/
示例
import java.util.LinkedList;
class LinkedListClone {
public static void main(String[] args) {
// create a LinkedList
LinkedList<String> list = new LinkedList<String>();
// Adding elements to the LinkedList
list.add("Element1");
list.add("Element2");
list.add("Element3");
list.add("Element4");
// Displaying LinkedList elements
System.out.println("LinkedList elements: "+list);
// Creating another list
LinkedList<String> list2 = new LinkedList<String>();
// Clone list to list2
/* public Object clone(): Returns a shallow copy of this
* LinkedList. (The elements themselves are not cloned.)
*/
list2 = (LinkedList)list.clone();
// Displaying elements of second LinkedList
System.out.println("List 2 Elements: "+list2);
}
}
输出：
LinkedList elements: [Element1, Element2, Element3, Element4]
List 2 Elements: [Element1, Element2, Element3, Element4]
Java - 获取LinkedList中元素的最后一次出现的索引
原文： https://beginnersbook.com/2014/08/java-get-the-index-of-last-occurrence-of-an-element-in-linkedlist/
描述
编程以找出LinkedList中最后一个元素出现的索引。
程序
import java.util.LinkedList;
class LinkedListExample {
public static void main(String[] args) {
// create a LinkedList
LinkedList<String> list = new LinkedList<String>();
// Add elements
list.add("AA");
list.add("BB");
list.add("CC");
list.add("AA");
list.add("DD");
list.add("AA");
list.add("EE");
// Display LinkedList elements
System.out.println("LinkedList elements: "+list);
// get the index of last occurrence of element "AA"
/* public int lastIndexOf(Object o): Returns the index
* of the last occurrence of the specified element in
* this list, or -1 if this list does not contain the
* element.
*/
System.out.println("LastIndex of AA:"+list.lastIndexOf("AA"));
// get the index of last occurrence of element "ZZ"
/* Note: The element ZZ does not exist in the list so
* the method lastIndexOf would return -1 for it.
*/
System.out.println("LastIndex of ZZ:"+list.lastIndexOf("ZZ"));
}
}
输出：
LinkedList elements: [AA, BB, CC, AA, DD, AA, EE]
LastIndex of AA:5
LastIndex of ZZ:-1
LinkedList push()和pop()方法
原文： https://beginnersbook.com/2014/08/linkedlist-push-and-pop-methods-java/
描述
用于演示LinkedList上的推送和弹出操作的程序。
LinkedList.push(E e)
public void push(E e)：将元素插入列表的前面。
示例：
import java.util.LinkedList;
class LinkedListExample {
public static void main(String[] args) {
// Create a LinkedList of Strings
LinkedList<String> list = new LinkedList<String>();
// Add few Elements
list.add("Jack");
list.add("Robert");
list.add("Chaitanya");
list.add("kate");
// Display LinkList elements
System.out.println("LinkedList contains: "+list);
// push Element the list
list.push("NEW ELEMENT");
// Display after push operation
System.out.println("LinkedList contains: "+list);
}
}
输出：
LinkedList contains: [Jack, Robert, Chaitanya, kate]
LinkedList contains: [NEW ELEMENT, Jack, Robert, Chaitanya, kate]
LinkedList.pop()
public E pop()：删除并返回列表的第一个元素。
示例：
import java.util.LinkedList;
class LinkedListPopDemo{
public static void main(String[] args) {
// Create a LinkedList of Strings
LinkedList<String> list = new LinkedList<String>();
// Add few Elements
list.add("Jack");
list.add("Robert");
list.add("Chaitanya");
list.add("kate");
// Display LinkList elements
System.out.println("LinkedList before: "+list);
// pop Element from list and display it
System.out.println("Element removed: "+list.pop());
// Display after pop operation
System.out.println("LinkedList after: "+list);
}
}
输出：
LinkedList before: [Jack, Robert, Chaitanya, kate]
Element removed: Jack
LinkedList after: [Robert, Chaitanya, kate]
Java - LinkedList poll()，pollFirst()和pollLast()方法
原文： https://beginnersbook.com/2014/08/java-linkedlist-poll-pollfirst-and-polllast-methods/
描述
示例LinkedList类的poll()，pollFirst()和pollLast()方法的程序。
LinkedList.poll()
检索并删除此列表的头部（第一个元素）。
import java.util.LinkedList;
class LinkedListPollMethod{
public static void main(String[] args) {
// Create a LinkedList of Strings
LinkedList<String> list = new LinkedList<String>();
// Add few Elements
list.add("Element1");
list.add("Element2");
list.add("Element3");
list.add("Element4");
// Display LinkList elements
System.out.println("LinkedList before: "+list);
/* poll(): Retrieves and removes the head (first element)
* of this list.
*/
System.out.println("Element removed: "+list.poll());
// Displaying list elements after poll() operation
System.out.println("LinkedList after: "+list);
}
}
输出：
LinkedList before: [Element1, Element2, Element3, Element4]
Element removed: Element1
LinkedList after: [Element2, Element3, Element4]
LinkedList.pollFirst()
public E pollFirst()：检索并删除此列表的第一个元素，如果此列表为空，则返回null。
import java.util.LinkedList;
class LinkedListPollFirstDemo{
public static void main(String[] args) {
// Create a LinkedList of Strings
LinkedList<String> list = new LinkedList<String>();
// Add few Elements
list.add("Element1");
list.add("Element2");
list.add("Element3");
list.add("Element4");
// Display LinkList elements
System.out.println("LinkedList before: "+list);
/* pollFirst(): Retrieves and removes the first element
* of this list, or returns null if this list is empty.
*/
System.out.println("Element removed: "+list.pollFirst());
// Display list after calling pollFirst() method
System.out.println("LinkedList after: "+list);
}
}
输出：
LinkedList before: [Element1, Element2, Element3, Element4]
Element removed: Element1
LinkedList after: [Element2, Element3, Element4]
LinkedList.pollLast()
public E pollLast()：检索并删除此列表的最后一个元素，如果此列表为空，则返回null。
import java.util.LinkedList;
class LinkedListPollLastDemo{
public static void main(String[] args) {
// Create a LinkedList of Strings
LinkedList<String> list = new LinkedList<String>();
// Add few Elements
list.add("Element1");
list.add("Element2");
list.add("Element3");
list.add("Element4");
// Display LinkList elements
System.out.println("LinkedList before: "+list);
/* pollFirst(): Retrieves and removes the first element
* of this list, or returns null if this list is empty.
*/
System.out.println("Element removed: "+list.pollLast());
// Display after calling pollLast() method
System.out.println("LinkedList after: "+list);
}
}
输出：
LinkedList before: [Element1, Element2, Element3, Element4]
Element removed: Element4
LinkedList after: [Element1, Element2, Element3]
Java - LinkedList peek()，peekFirst()和peekLast()方法
原文： https://beginnersbook.com/2014/08/java-linkedlist-peek-peekfirst-and-peeklast-methods/
描述
public E peek()：检索但不删除此列表的头部（第一个元素）。
public E peekFirst()：检索但不删除此列表的第一个元素，如果此列表为空，则返回null。
public E peekLast()：检索但不删除此列表的最后一个元素，如果此列表为空，则返回null。
示例
import java.util.LinkedList;
class LinkedListPeekDemo{
public static void main(String[] args) {
// Create a LinkedList of Strings
LinkedList<String> list = new LinkedList<String>();
// Add few Elements
list.add("Element1");
list.add("Element2");
list.add("Element3");
list.add("Element4");
// Display LinkList elements
System.out.println("LinkedList before: "+list);
//peek()
System.out.println(list.peek());
//peekFirst()
System.out.println(list.peekFirst());
//peekLast()
System.out.println(list.peekLast());
// Should be same as peek methods does not remove
System.out.println("LinkedList after: "+list);
}
}
输出：
LinkedList before: [Element1, Element2, Element3, Element4]
Element1
Element1
Element4
LinkedList after: [Element1, Element2, Element3, Element4]
转换
Java - 将LinkedList转换为ArrayList
原文： https://beginnersbook.com/2014/07/java-convert-a-linkedlist-to-arraylist/
示例
在这个例子中，我们将LinkedList转换为ArrayList。我们有一个LinkedList<String>，我们在其中存储了 5 个人的名字。转换后，我们将显示ArrayList的元素，以确保ArrayList具有与LinkedList相同的元素。完整的计划如下：
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class ConvertExample {
public static void main(String[] args) {
LinkedList<String> linkedlist = new LinkedList<String>();
linkedlist.add("Harry");
linkedlist.add("Jack");
linkedlist.add("Tim");
linkedlist.add("Rick");
linkedlist.add("Rock");
List<String> list = new ArrayList<String>(linkedlist);
for (String str : list){
System.out.println(str);
}
}
}
输出：
Harry
Jack
Tim
Rick
Rock
如何在 Java 中查找ArrayList的长度
原文： https://beginnersbook.com/2013/12/how-to-find-length-of-arraylist-in-java/
通过使用ArrayList size() ArrayList类的方法，我们可以很容易地确定ArrayList的大小。此方法返回ArrayList的元素数。
public int size()
示例：
package beginnersbook.com;
import java.util.ArrayList;
public class Details
{
public static void main(String [] args)
{
ArrayList<Integer> al=new ArrayList<Integer>();
System.out.println("Initial size: "+al.size());
al.add(1);
al.add(13);
al.add(45);
al.add(44);
al.add(99);
System.out.println("Size after few additions: "+al.size());
al.remove(1);
al.remove(2);
System.out.println("Size after remove operations: "+al.size());
System.out.println("Final ArrayList: ");
for(int num: al){
System.out.println(num);
}
}
}
输出：
Initial size: 0
Size after few additions: 5
Size after remove operations: 3
Final ArrayList:
1
45
99
如何使用 Java 中的toArray()将LinkedList转换为数组
原文： https://beginnersbook.com/2014/07/how-to-convert-linkedlist-to-array-using-toarray-in-java/
将LinkedList转换为数组非常简单。您可以将任何类型的LinkedList（例如double，String，int等）转换为相同类型的数组。在本教程中，我们将看到此类转换的示例。
示例
这里我们将LinkedList的字符串转换为String数组（LinkedList到String[]）。在程序结束时，我们已经提到了如何将任何其他类型的列表（如double，int等）转换为相应的数组类型。
import java.util.LinkedList;
public class ConvertExample {
public static void main(String[] args) {
//Creating and populating LinkedList
LinkedList<String> linkedlist = new LinkedList<String>();
linkedlist.add("Harry");
linkedlist.add("Maddy");
linkedlist.add("Chetan");
linkedlist.add("Chauhan");
linkedlist.add("Singh");
//Converting LinkedList to Array
String[] array = linkedlist.toArray(new String[linkedlist.size()]);
//Displaying Array content
System.out.println("Array Elements:");
for (int i = 0; i < array.length; i++)
{
System.out.println(array[i]);
}
}
}
输出：
Array Elements:
Harry
Maddy
Chetan
Chauhan
Singh
正如您所看到的，我们在LinkedList中拥有与数组中相同的元素。
注意：
在上面的例子中，我们采用了String的LinkedList，但是如果你有一个不同类型的LinkedList，那么你可以像这样改变转换逻辑。
对于LinkedList转换逻辑将是：
Double[] array = linkedlist.toArray(new Double[linkedlist.size()]);
类似地，LinkedList转换逻辑将是：
Integer[] array = linkedlist.toArray(new Integer[linkedlist.size()]);
更多关于 Javadoc 的 toArray()方法：
public T[] toArray(T[] a)：它以适当的顺序返回一个包含该列表中所有元素的数组（从第一个元素到最后一个元素）;返回数组的运行时类型是指定数组的运行时类型。如果列表适合指定的数组，则返回其中。否则，将使用指定数组的运行时类型和此列表的大小分配新数组。
如果列表适合指定的数组，并且有空余空间（即，数组的元素多于列表），则紧跟在列表末尾之后的数组中的元素将设置为null。 （仅当调用者知道列表不包含任何null元素时，这在确定列表长度时很有用。）
Vector
Vector基础知识
Java 中的Vector
Vector实现List接口。与ArrayList一样，它也维护插入顺序，但它很少在非线程环境中使用，因为它是同步的，因此它在搜索，添加，删除和更新其元素时表现不佳。
创建向量类对象的三种方法：
方法 1：
Vector vec = new Vector();
它创建一个空的Vector，默认初始容量为 10。这意味着当需要将第 11 个元素插入Vector时，将重新调整Vector的大小。注意：默认情况下，向量将其大小加倍。即，在这种情况下，Vector大小将保持 10 到 10 次插入，一旦我们尝试插入第 11 个元素，它将变为 20（默认容量 10 的两倍）。
方法 2：
语法：Vector object= new Vector(int initialCapacity)
Vector vec = new Vector(3);
它将创建一个初始容量为 3 的Vector。
方法 3：
语法：
Vector object= new vector(int initialcapacity, capacityIncrement)
例：
Vector vec= new Vector(4, 6)
这里我们提供了两个论点。初始容量为 4，capacityIncrement为 6。这意味着插入第 5 个元素时，大小为 10（4 + 6），第 11 个插入时为 16（10 + 6）。
Java 中Vector的完整示例：
import java.util.*;
public class VectorExample {
public static void main(String args[]) {
/* Vector of initial capacity(size) of 2 */
Vector<String> vec = new Vector<String>(2);
/* Adding elements to a vector*/
vec.addElement("Apple");
vec.addElement("Orange");
vec.addElement("Mango");
vec.addElement("Fig");
/* check size and capacityIncrement*/
System.out.println("Size is: "+vec.size());
System.out.println("Default capacity increment is: "+vec.capacity());
vec.addElement("fruit1");
vec.addElement("fruit2");
vec.addElement("fruit3");
/*size and capacityIncrement after two insertions*/
System.out.println("Size after addition: "+vec.size());
System.out.println("Capacity after increment is: "+vec.capacity());
/*Display Vector elements*/
Enumeration en = vec.elements();
System.out.println("\nElements are:");
while(en.hasMoreElements())
System.out.print(en.nextElement() + " ");
}
}
输出：
Size is: 4
Default capacity increment is: 4
Size after addition: 7
Capacity after increment is: 8
Elements are:
Apple Orange Mango Fig fruit1 fruit2 fruit3
常用的Vector类方法：
void addElement(Object element)：它在Vector的末尾插入元素。int capacity()：此方法返回向量的当前容量。int size()：它返回向量的当前大小。void setSize(int size)：它使用指定的大小更改现有大小。boolean contains(Object element)：此方法检查Vector中是否存在指定的元素。如果找到该元素，则返回true，否则返回false。boolean containsAll(Collection c)：如果Vector中存在集合c的所有元素，则返回true。Object elementAt(int index)：它返回Vector中指定位置的元素。Object firstElement()：它用于获取向量的第一个元素。Object lastElement()：返回数组的最后一个元素。Object get(int index)：返回指定索引处的元素。boolean isEmpty()：如果Vector没有任何元素，则此方法返回true。boolean remove(Object element)：从向量中移除指定的元素。boolean removeAll(Collection c)：它从向量中删除所有存在于Collection c中的元素。void setElementAt(Object element, int index)：它使用给定元素更新指定索引的元素。
Vector教程
这是 beginnersbook.com 上发布的Vector教程列表。学习快乐！
Vector基础知识
删除/排序/替换
Iterator/ListIterator/Enum
转换
差异
参考
如何在 java 中获取Vector的子列表
原文： https://beginnersbook.com/2014/06/how-to-get-sub-list-of-vector-example-in-java/
在这个例子中，我们将看到如何从Vector获取元素的子列表。我们将使用Vector类的subList()方法来执行此操作。
关于javadoc的这个方法的更多信息：
public List subList(int fromIndex, int toIndex)：它返回此List在fromIndex（包含）和toIndex（独占）之间的视图。（如果fromIndex和toIndex相等，则返回的List为空。）返回的List由此List支持，因此返回List中的更改将反映在此List中，反之亦然。返回的List支持此List支持的所有可选List操作。
此方法消除了对显式范围操作的需要（对于数组通常存在的排序）。任何期望List的操作都可以通过操作subList视图而不是整个List来用作范围操作。例如，以下语句从List中删除了一系列元素：
list.subList(from, to).clear();
示例
import java.util.Vector;
import java.util.List;
public class SublistExample {
public static void main(String[] args) {
// Step 1: Create a Vector
Vector<String> vector = new Vector<String>();
// Step 2: Add elements
vector.add("Item1");
vector.add("Item2");
vector.add("Item3");
vector.add("Item4");
vector.add("Item5");
vector.add("Item6");
/* The method subList(int fromIndex, int toIndex)
* returns a List having elements of Vector
* starting from index fromIndex
* to (toIndex - 1).
*/
List subList = vector.subList(2,5);
System.out.println("Sub list elements :");
for(int i=0; i < subList.size() ; i++){
System.out.println(subList.get(i));
}
}
}
输出：
Sub list elements :
Item3
Item4
Item5
如何使用 Java 中的Collections.sort对Vector进行排序
原文： https://beginnersbook.com/2014/06/how-to-sort-vector-using-collections-sort-in-java-example/
Vector维护插入顺序，这意味着它以相同的顺序显示元素，并将它们添加到Vector中。在这个例子中，我们将看到如何使用Collections.sort()按升序对Vector元素进行排序。步骤如下：
1）创建一个Vector对象
2）使用add(Element e)方法向Vector添加元素
3）使用Collections.sort(Vector)对其进行排序
4）显示已排序的元素列表。
import java.util.Collections;
import java.util.Vector;
public class SortingVectorExample {
public static void main(String[] args) {
// Create a Vector
Vector<String> vector = new Vector<String>();
//Add elements to Vector
vector.add("Walter");
vector.add("Anna");
vector.add("Hank");
vector.add("Flynn");
vector.add("Tom");
// By Default Vector maintains the insertion order
System.out.println("Vector elements before sorting: ");
for(int i=0; i < vector.size(); i++){
//get(i) method fetches the element from index i
System.out.println(vector.get(i));
}
// Collection.sort() sorts the collection in ascending order
Collections.sort(vector);
//Display Vector elements after sorting using Collection.sort
System.out.println("Vector elements after sorting: :");
for(int i=0; i < vector.size(); i++){
System.out.println(vector.get(i));
}
}
}
输出：
Vector elements before sorting:
Walter
Anna
Hank
Flynn
Tom
Vector elements after sorting: :
Anna
Flynn
Hank
Tom
Walter
使用索引在 Java 中搜索元素
原文： https://beginnersbook.com/2014/06/search-elements-in-vector-using-index-java-example/
在本教程中，我们将学习以下四种使用索引值在Vector中搜索元素的方法。
1）public int indexOf(Object o)：返回Vector中第一次出现的对象o的索引。
2）public int indexOf(Object o, int startIndex)：返回此向量中第一次出现的对象o的索引，从startIndex（包括）开始向前搜索。
3）public int lastIndexOf(Object o)：返回Vector中最后一次出现的对象o的索引。
4）public int lastIndexOf(Object o, int startIndex)：它返回此向量中最后一次出现的指定元素的索引，从startIndex（包括）向后搜索。
示例
在这个例子中，我们使用了上面提到的所有四种方法来证明它们的工作原理。
import java.util.Vector;
public class SearchVector {
public static void main(String[] args) {
// Create a Vector object
Vector<String> vector = new Vector<String>();
//Add elements to Vector
vector.add("Kate");
vector.add("Patt");
vector.add("Kluge");
vector.add("Karon");
vector.add("Patt");
vector.add("Monica");
vector.add("Patt");
//This would return the index of first occurrence
int first_index = vector.indexOf("Patt");
System.out.println("First Occurrence of Patt at index: "+first_index);
//This would return the index of last occurrence
int last_index = vector.lastIndexOf("Patt");
System.out.println("Last Occurrence of Patt at index: "+last_index);
//This would start search from index 2(inclusive)
int after_index = vector.indexOf("Patt", 2);
System.out.println("Occurrence after index 2: "+after_index);
//This would search the element backward starting from index 6(inclusive)
int before_index = vector.lastIndexOf("Patt", 6);
System.out.println("Occurrence before index 6: "+before_index);
}
}
输出：
First Occurrence of Patt at index: 1
Last Occurrence of Patt at index: 6
Occurrence after index 2: 4
Occurrence before index 6: 6
参考
将一个Vector的所有元素复制到另一个Vector
原文： https://beginnersbook.com/2013/12/copy-all-the-elements-of-one-vector-to-another-vector-example/
在这个例子中，我们将看到如何将Vector的所有元素复制到另一个Vector。该过程用第一向量的对应元素替换第二向量的现有元素。对于例如如果我们将向量v1复制到向量v2，那么v2的第一个元素将被v1的第一个元素替换，依此类推。
在下面的代码中，我们有两个向量va和vb和我们正在使用[Collections.copy()](https://docs.oracle.com/javase/7/docs/api/java/util/Collections.html#copy(java.util.List, java.util.List))方法将va的所有元素复制到vb。
例：
import java.util.Collections;
import java.util.Vector;
public class VectorCopyExample {
public static void main(String args[])
{
//First Vector of String type
Vector<String> va = new Vector<String>();
//Adding elements to the first Vector
va.add("AB");
va.add("BC");
va.add("CD");
va.add("DE");
//Second Vector
Vector<String> vb = new Vector<String>();
//Adding elements to the second Vector
vb.add("1st");
vb.add("2nd");
vb.add("3rd");
vb.add("4th");
vb.add("5th");
vb.add("6th");
/*Displaying the elements of second vector before
performing the copy operation*/
System.out.println("Vector vb before copy: "+vb);
//Copying all the elements of Vector va to Vector vb
Collections.copy(vb, va);
//Displaying elements after copy
System.out.println("Vector vb after copy: "+vb);
}
}
输出：
Vector vb before copy: [1st, 2nd, 3rd, 4th, 5th, 6th]
Vector vb after copy: [AB, BC, CD, DE, 5th, 6th]
Vector中的删除/排序/替换
删除Vector元素
原文： https://beginnersbook.com/2014/06/remove-vector-element-java-example/
在这个例子中，我们将看到如何从Vector中删除元素。我们将使用Vector API的sremove(Object o)方法以删除指定的元素。
public boolean remove(Object o)：从Vector中删除第一次出现的指定元素如果Vector不包含该元素，则不变。
示例
在这个例子中，我们从Vector<String>中删除两个String值。步骤如下：
1）创建Vector
2）使用Vector类的add(Element e)方法向Vector添加元素。
3）使用Vector的remove(Object o)方法删除元素。
import java.util.Vector;
public class RemoveFromVector {
public static void main(String[] args) {
// Creating a Vector of String Elements
Vector<String> vector = new Vector<String>();
//Adding elements to the Vector
vector.add("Harry");
vector.add("Steve");
vector.add("Vince");
vector.add("David");
vector.add("Matt");
System.out.println("Vector elements before remove(): ");
for(int i=0; i < vector.size(); i++)
{
System.out.println(vector.get(i));
}
// Removing Harry
vector.remove("Harry");
// Removing Matt
vector.remove("Matt");
System.out.println("\nVector elements after remove(): ");
for(int i=0; i < vector.size(); i++)
{
System.out.println(vector.get(i));
}
}
}
输出：
Vector elements before remove():
Harry
Steve
Vince
David
Matt
Vector elements after remove():
Steve
Vince
David
remove(Object o)方法返回boolean值。如果Vector中存在指定的元素，则返回true，否则返回false。
ArrayList排序
如何在 java 中使用索引删除Vector元素
原文： https://beginnersbook.com/2014/06/how-to-remove-vector-elements-using-index-in-java-example/
在本教程中，我们将学习如何使用索引从Vector中删除元素。我们将使用Vector类的remove(int index)方法。
public E remove(int index)：删除此Vector中指定位置的元素。将任何后续元素向左移位（从索引中减去一个）。返回从Vector中删除的元素。
示例
索引从 0 开始，所以如果我们调用remove(2)，它将从Vector中删除第 3 个元素。
import java.util.Vector;
public class RemoveExample {
public static void main(String[] args) {
// Creating a Vector of Strings
Vector<String> vector = new Vector<String>();
//Adding elements to the Vector
vector.add("C++");
vector.add("Java");
vector.add("Cobol");
vector.add("C");
vector.add("Oracle");
System.out.println("Vector elements before remove(): ");
for(int i=0; i < vector.size(); i++)
{
System.out.println(vector.get(i));
}
// Removing 3rd element from Vector
Object obj = vector.remove(2);
System.out.println("\nElement removed from Vector is:");
System.out.println(obj);
System.out.println("\nVector elements after remove():");
for(int i=0; i < vector.size(); i++)
{
System.out.println(vector.get(i));
}
}
}
输出：
Vector elements before remove():
C++
Java
Cobol
C
Oracle
Element removed from Vector is:
Cobol
Vector elements after remove():
C++
Java
C
Oracle
这是从指定索引中删除Vector元素的示例。
从 Java 中的Vector中删除所有元素
原文： https://beginnersbook.com/2014/06/remove-all-elements-from-vector-in-java-example/
在这个例子中，我们将看到如何从Vector中删除所有元素。我们将使用Vector类的clear()方法来做到这一点。
public void clear()：删除此Vector中的所有元素。此方法调用后，Vector将为空。
示例
这里我们在调用clear()方法之前和之后显示Vector的大小。步骤如下：
1）创建一个Vector。
2）添加元素。
3）调用clear()方法删除所有元素。
import java.util.Vector;
public class RemoveAll {
public static void main(String[] args) {
// Creating a Vector of Strings
Vector<String> vector = new Vector<String>();
//Adding elements to the Vector
vector.add("C++");
vector.add("Java");
vector.add("Cobol");
vector.add("C");
vector.add("Oracle");
System.out.println("Current size of Vector: "+vector.size());
// Calling clear() method of Vector API
vector.clear();
System.out.println("Size of Vector after clear(): "+vector.size());
}
}
输出：
Current size of Vector: 5
Size of Vector after clear(): 0
使用索引替换Vector元素
原文： https://beginnersbook.com/2014/06/replace-vector-elements-using-index-java-example/
在本教程中，我们将了解如何替换Vector元素。我们将使用Vector类的set()方法来做到这一点。
public E set(int index, E element)：用指定的元素替换此Vector中指定位置的元素。
示例
在这个例子中，我们用新值替换Vector的第 2 和第 3 个元素。
import java.util.Vector;
public class ReplaceElements {
public static void main(String[] args) {
Vector<String> vector = new Vector<String>();
vector.add("Harry");
vector.add("Steve");
vector.add("Vince");
vector.add("David");
vector.add("Matt");
System.out.println("Vector elements before replacement: ");
for(int i=0; i < vector.size(); i++)
{
System.out.println(vector.get(i));
}
//Replacing index 1 element
vector.set(1,"Mark");
//Replacing index 2 element
vector.set(2,"Jack");
System.out.println("Vector elements after replacement: ");
for(int i=0; i < vector.size(); i++)
{
System.out.println(vector.get(i));
}
}
}
输出：
Vector elements before replacement:
Harry
Steve
Vince
David
Matt
Vector elements after replacement:
Harry
Mark
Jack
David
Matt
如何设置Vector大小
原文： https://beginnersbook.com/2014/06/how-to-set-vector-size-example/
我们可以使用Vector类的setSize()方法设置Vector的大小。如果新大小大于当前大小，则当前大小索引之后的所有元素都具有空值。如果新大小小于当前大小，则已从Vector中删除当前大小索引之后的元素。
示例
Vector最初有 5 个元素。我们将大小设置为 10，因此在Vector的末尾插入了 5 个null元素。
在程序的第二部分，我们将大小设置为 4（小于当前大小 10），因此最后六个元素从Vector中删除（包括null元素）。
import java.util.Vector;
public class SetSizeExample {
public static void main(String[] args) {
// Create a Vector
Vector<String> vector = new Vector<String>();
//Add elements to Vector
vector.add("Walter");
vector.add("Anna");
vector.add("Hank");
vector.add("Flynn");
vector.add("Tom");
//Setting up the size greater than current size
vector.setSize(10);
System.out.println("Vector size: "+vector.size());
System.out.println("Vector elements: ");
for(int i=0; i < vector.size(); i++){
//get(i) method fetches the element from index i
System.out.println(vector.get(i));
}
//Setting up the size less than current size
vector.setSize(4);
System.out.println("\nVector size: "+vector.size());
System.out.println("Vector elements: ");
for(int i=0; i < vector.size(); i++){
System.out.println(vector.get(i));
}
}
}
输出：
Vector size: 10
Vector elements:
Walter
Anna
Hank
Flynn
Tom
null
null
null
null
null
Vector size: 4
Vector elements:
Walter
Anna
Hank
Flynn
Iterator/ListIterator/Enum
Java 中的Vector Enumeration
原文： https://beginnersbook.com/2014/06/vector-enumeration-example-in-java/
在这个例子中，我们使用Enumeration迭代Vector。步骤如下：
1）创建一个Vector对象
2）使用Vector类的add()方法向向量添加元素。
3）调用elements()方法获取指定Vector的枚举
4）使用Enumeration方法hashMoreElements()和nextElement()迭代Vector。
示例：完整代码
import java.util.Vector;
import java.util.Enumeration;
public class VectorEnumerationExample {
public static void main(String[] args) {
// Create a Vector
Vector<String> vector = new Vector<String>();
// Add elements into Vector
vector.add("Chaitanya");
vector.add("Shubham");
vector.add("Apoorv");
vector.add("Jin");
vector.add("Jacob");
// Get Enumeration of Vector elements
Enumeration en = vector.elements();
/* Display Vector elements using hashMoreElements()
* and nextElement() methods.
*/
System.out.println("Vector elements are: ");
while(en.hasMoreElements())
System.out.println(en.nextElement());
}
}
输出：
Vector elements are:
Chaitanya
Shubham
Apoorv
Jin
Jacob
Java 中的Vector迭代器
原文： https://beginnersbook.com/2014/06/vector-iterator-example-in-java/
在上一个教程中，我们学习了如何使用ListIterator在两个方向（前进和后退）中遍历Vector。在这个例子中，我们将看到如何使用Iterator遍历Vector。步骤如下：
1）创建一个Vector
2）使用Vector类的add(Element E)方法向其中添加元素
3）通过调用Vector的iterator()方法获取迭代器。
4）使用迭代器的hasNext()和next()方法遍历Vector。
示例
import java.util.Vector;
import java.util.ListIterator;
import java.util.Iterator;
public class VectorIteratorExample {
public static void main(String[] args) {
// Creating a Vector of Strings
Vector<String> vector = new Vector<String>();
//Adding elements to the Vector
vector.add("Mango");
vector.add("Orange");
vector.add("Apple");
vector.add("Grapes");
vector.add("Kiwi");
//Obtaining an iterator
Iterator it = vector.iterator();
System.out.println("Vector elements are:");
while(it.hasNext()){
System.out.println(it.next());
}
}
}
输出：
Vector elements are:
Mango
Orange
Apple
Grapes
Kiwi
Java 中的Vector ListIterator
原文： https://beginnersbook.com/2014/06/vector-listiterator-example-in-java/
我们可以使用ListIterator在前进和后退方向上遍历Vector。除此之外，我们还可以使用 ListIterator API 的方法执行其他几个操作，例如显示下一个和前一个元素的索引，替换元素值，在迭代期间删除元素等。
示例
这里我们有一个字符串向量，我们使用ListIterator在两个方向上迭代它。
import java.util.Vector;
import java.util.ListIterator;
public class VectorListIteratorDemo {
public static void main(String[] args) {
// Create a Vector
Vector<String> vector = new Vector<String>();
//Adding elements to the Vector
vector.add("Item1");
vector.add("Item2");
vector.add("Item3");
vector.add("Item4");
vector.add("Item5");
ListIterator litr = vector.listIterator();
System.out.println("Traversing in Forward Direction:");
while(litr.hasNext())
{
System.out.println(litr.next());
}
System.out.println("\nTraversing in Backward Direction:");
while(litr.hasPrevious())
{
System.out.println(litr.previous());
}
}
}
输出：
Traversing in Forward Direction:
Item1
Item2
Item3
Item4
Item5
Traversing in Backward Direction:
Item5
Item4
Item3
Item2
Item1
参考：
ListIterator javadoc
Vector Javadoc
转换
Java - 将Vector转换为List
原文： https://beginnersbook.com/2014/07/java-convert-vector-to-list-example/
之前我们有Vector到ArrayList和Vector到数组的转换。在本教程中，我们将看到如何将Vector转换为List。步骤如下：
1）创建一个Vector并填充它
2）通过调用返回List对象的Collections.list(vector.elements())将其转换为List。
示例
为了解释逻辑，我们假设Vector具有String元素。但是，如果您想要使用其他类型，则只需更改以下代码中的泛型。
import java.util.Vector;
import java.util.List;
import java.util.Collections;
public class VectorToList {
public static void main(String[] args) {
// Step1: Creating a Vector of String elements
Vector<String> vector = new Vector<String>();
// Step2: Populating Vector
vector.add("Tim");
vector.add("Rock");
vector.add("Hulk");
vector.add("Rick");
vector.add("James");
// Step3: Displaying Vector elements
System.out.println("Vector Elements :");
for (String str : vector){
System.out.println(str);
}
// Step4: Converting Vector to List
List<String> list = Collections.list(vector.elements());
// Step 5: Displaying List Elements
System.out.println("\nList Elements :");
for (String str2 : list){
System.out.println(str2);
}
}
}
输出：
Vector Elements :
Tim
Rock
Hulk
Rick
James
List Elements :
Tim
Rock
Hulk
Rick
James
正如您所看到的，Vector和List在转换后具有相同的元素。