在本文中，我们将给您介绍关于排序JavaArrayList的一部分的详细内容，并且为您解答java中arraylist排序的相关问题，此外，我们还将为您提供关于ArrayList.toArray（）中

在本文中，我们将给您介绍关于排序Java ArrayList的一部分的详细内容，并且为您解答java中arraylist排序的相关问题，此外，我们还将为您提供关于ArrayList.toArray（）中的Java泛型 - Java generics in ArrayList.toArray()、ArrayList的Java ArrayList、Arrays.asList()返回的ArrayList，这是Arrays里内嵌的一个私有静态类，而并不是java.util.ArrayList类、Java ArrayList使用技巧 - 两个ArrayList去除重复的元素的知识。

• 排序Java ArrayList的一部分（java中arraylist排序）
• ArrayList.toArray（）中的Java泛型 - Java generics in ArrayList.toArray()
• ArrayList的Java ArrayList
• Arrays.asList()返回的ArrayList，这是Arrays里内嵌的一个私有静态类，而并不是java.util.ArrayList类
• Java ArrayList使用技巧 - 两个ArrayList去除重复的元素

排序Java ArrayList的一部分（java中arraylist排序）

仅对ArrayList的一部分进行排序的 最有效 方法是什么？说一个包含10个元素的Arraylist中从索引0到3的所有元素。

Java中有可用的库函数吗？

除了Collections.sort(list)排序整个列表！

编写高度优化的自定义排序功能将需要一些工作。

答案1

Collections.sort(list.subList(0,3));Note: ''3'' here is excluded from sorting

在文档中对此进行了描述：

公共列表subList（int fromIndex，int toIndex）

返回此列表中指定的fromIndex（包括）和toIndex（不包括）之间的视图。

ArrayList.toArray（）中的Java泛型 - Java generics in ArrayList.toArray()

问题：

Say you have an arraylist defined as follows: 假设你有一个arraylist定义如下：

ArrayList<String> someData = new ArrayList<>();

Later on in your code, because of generics you can say this: 稍后在您的代码中，由于泛型，您可以这样说：

String someLine = someData.get(0);

And the compiler knows outright that it will be getting a string. 并且编译器完全知道它将获得一个字符串。 Yay generics! 是的仿制药！ However, this will fail: 但是，这将失败：

String[] arrayOfData = someData.toArray();

toArray() will always return an array of Objects, not of the generic that was defined. toArray()将始终返回一个Object数组，而不是已定义的泛型数组。 Why does the get(x) method know what it is returning, but toArray() defaults to Objects? 为什么get(x)方法知道它返回什么，但toArray()默认为Objects？

解决方案：

ArrayList的Java ArrayList

[[100,200,300],[100,300]].

[[100,200]],

public static void main(String[] args) {
    ArrayList<ArrayList<Integer>> outer = new ArrayList<ArrayList<Integer>>();
    ArrayList<Integer> inner = new ArrayList<Integer>();

    inner.add(100);     
    inner.add(200);

    outer.add(inner);
    outer.add(inner);

    outer.get(0).add(300);

    System.out.println(outer);

}

Arrays.asList()返回的ArrayList，这是Arrays里内嵌的一个私有静态类，而并不是java.util.ArrayList类

测试代码：

package array;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class ArrayTest {
   
   
   

	@SuppressWarnings("unused")
	private static void asListTest(){
   
   
   
		String[] a = {
   
   
   "A", "B"};
		List<String> list = Arrays.asList(a);
		System.out.println(list.getClass().getName()); // java.util.Arrays$ArrayList
		System.out.println(list.contains("A")); // true
		list.add("C");
		/*
		 * Jerry: 2016-01-15 9:09PM:
	Arrays.asList() 会返回一个ArrayList，这是Arrays里内嵌的一个私有静态类，而并不是java.util.ArrayList类java.util.Arrays.ArrayList 有set(), get(), contains()方法，
	但并不支持添加元素，所以大小是固定的，想要创建一个真正的ArrayList，你应该：
	ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));
		 */
	}
	
	private static void removeInLoop() {
   
   
   
		ArrayList<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c", "d"));

		// 下面这段代码会触发ConcurrentModificationException异常
                // 不能在循环里直接修改一个集合类实例

		/*for (String s : list) {
		    if (s.equals("a"))
		        list.remove(s);
		}*/
                // 应该用迭代器来完成
		Iterator<String> iter = list.iterator();
		while (iter.hasNext()) {
   
   
   
		    String s = iter.next();

		    if (s.equals("a")) {
   
   
   
		        iter.remove();
		    }
		}
		list.forEach(System.out::println);
	}
	public static void main(String[] args) {
   
   
   
	    // asListTest();
		removeInLoop();
		String[] a = {
   
   
   "A", "B"};
		// internal implementation: return new ArrayList<>(a);
		List<String> list1 = Arrays.asList(a);
		List<String> list2 = Arrays.asList(a);
		List<String> list3 = Arrays.asList(a);
		System.out.println(list1);
		System.out.println(list2);
		System.out.println(list3);
                /* 这行代码会触发异常：
             Exception in thread "main" java.lang.UnsupportedOperationException
	     at java.base/java.util.AbstractList.add(AbstractList.java:153)
	     at java.base/java.util.AbstractList.add(AbstractList.java:111)
	     at array.ArrayTest.main(ArrayTest.java:57)
                */
		// list3.add("C");
		System.out.println(list1.getClass().getCanonicalName());
	}
}

本文分享 CSDN - 汪子熙。
如有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。

Java ArrayList使用技巧 - 两个ArrayList去除重复的元素

方法一、ArrayList中提供的removeAll方法（效率最低）

List1.removeAll(mSubList);

方法二、双重循环（比方法一效率高）

双重循环分为内外两层循环，经过测试，将元素多的list放在外层循环效率更高（mSubList中的元素可能比List1多）（被删除元素的列表List1放在外层循环和内层循环的实现方式有些差别），这里的测试数据是List1中的元素多，实现如下：

int maxSize = List1.size(); for (int i = maxSize-1; i >=0; i--) { int size = mSubList.size(); while (size > 0) { String s = mSubList.get(size-1); if (s.equals(List1.get(i))) { mSubList.remove(size-1); List1.remove(i); break; } size--; } }

方法三、利用HashMap（效率最高）

//第一步：构建list的HashMap,将list中的元素作为键，将list中的元素对应的位置作为值
// 如果不是String类，需要实现hashCode,equals方法,equals不一定要调用，但是一定要书写

Map<String, Integer> map = new HashMap<>(); for (int i = 0; i < List1.size(); i++) { map.put(List1.get(i), i); } //第二步：利用map遍历mSubList，查找重复元素 //把List1中所有查到的重复元素的位置置空 for (int i = 0; i < mSubList.size(); i++) { Integer pos = map.get(mSubList.get(i)); if (pos==null) { continue; } List1.set(pos, null); } //第三步：把List1中所有的空元素移除 for (int i = List1.size()-1; i>=0; i--) { if (List1.get(i)==null) { List1.remove(i); } }

方法三的一些说明

1. 方法三中初始化HashMap的时候已经知道了容量大小，理论上直接指定HashMap的大小避免扩容可以提高效率，但是测试发现并没有提高，100000条数据都是几十毫秒
2. 虽然方法三中HashMap存的值是整数，但是不要使用int pos = map.get(mSubList.get(i));取值，会崩溃
3. 第二步中，使用Integer pos = map.get(mSubList.get(i));取值，然后判断 pos 是否是空来判断map中是否包含键是mSubList.get(i)的值，比用map.containsKey(key)来判断然后get取值少访问一次哈希表
4. 第三步中，从List1尾部开始遍历移除

我们今天的关于排序Java ArrayList的一部分和java中arraylist排序的分享就到这里，谢谢您的阅读，如果想了解更多关于ArrayList.toArray（）中的Java泛型 - Java generics in ArrayList.toArray()、ArrayList的Java ArrayList、Arrays.asList()返回的ArrayList，这是Arrays里内嵌的一个私有静态类，而并不是java.util.ArrayList类、Java ArrayList使用技巧 - 两个ArrayList去除重复的元素的相关信息，可以在本站进行搜索。