文章
开始
开始学习
JavaRush /Java 博客 /Random-ZH /第 26 级。有关该级别主题的面试问题的答案。第 1 部分：问题 1-5、10。
zor07
第 31 级
Санкт-Петербург

第 26 级。有关该级别主题的面试问题的答案。第 1 部分：问题 1-5、10。

已在 Random-ZH 群组中发布
Java-университет
第 26 级。有关该级别主题的面试问题的答案。 第 1 部分. 问题 1-5, 10. - 1总结起来相当繁琐，所以我把它分成两部分。第二部分包含有关 kankarency 和多线程问题的答案。第一部分包含其余部分。写作是相当困难的。还是不太明白，所以一如既往，欢迎评论、评论、补充）

1.如何使用Comparable接口？

该接口Comparable仅声明一种方法compareTo(Object obj)，旨在实现类对象的排序。在对有序列表或对象数组进行排序时使用起来很方便。该方法将被调用的对象与 对象。 equals与返回 true或 false 的方法相反， compareTo返回：
  • 如果值相等则为 0；
  • 如果被调用者小于参数，则为负值；
  • 如果被调用者大于参数，则为正。
它主要用于对有序列表 ( java.util.List) 和对象数组进行排序。如果列表/数组包含实现此接口的元素，那么它们可以通过 java.util.Collections.sort(List)/Arrays.sort(Object[]). 自然排序的概念与接口相关联 Comparable，因为它为实现该接口的任何类的实例建立了自然顺序。换句话说，顺序 (x, y) 对应于条件 的满足 x.compareTo(y) <= 0。实现的规则 Comparable，或者更确切地说，其方法的规则 compareTo(Object)如下（x 和 y 是实现 的类的实例 Comparable）：
  • x.compareTo(y)如果 x 应位于 y 之前或之后，则分别返回 -1 或 1。如果该方法返回 0，则阶数 (x, y) 和 (y, x) 相等。
  • 如果sign(a)是一个函数，对于 a 分别返回 -1,0,1，小于 0，等于 0 和大于 0，则必须满足等式sign(x.compareTo(y))==-sign(y.compareTo(x))。这是合乎逻辑的：如果 x 在 y 之前，那么 y 必须在 x 之后，反之亦然。
  • 如果x.compareTo(y) > 0和y.compareTo(z) > 0，那么x.compareTo(z) > 0– 不等式的传递性关系。
  • 如果x.compareTo(y) == 0，则sign(x.compare(z)) == sign(y.compareTo(z))，对于任意 z。
  • 该调用x.compareTo(null)必须抛出异常NullPointerException。这与实现逻辑存在差异equals（让我提醒你，x.equals(null)它返回false）。
  • 如果 y 的类型无法与 x 进行比较，则调用x.compareTo(y)必须抛出异常ClassCastException。
  • (x.compareTo(y) == 0) == x.equals(y)， IE。x.compareTo(y)当且仅当x.equals(y)返回true时，该调用必须返回 0 。这是一个一致性规则，考虑起来非常重要。
资料来源：

2. 比较器接口如何使用？

该接口 Comparator声明了两个方法 compare(Object obj1, Object obj2)和 equals(Object obj)。使用接口时 Comparator，比较一对对象的逻辑并不隐藏在类/对象内部，而是在单独的类中实现。方法 compare(x,y)与调用完全一样 x.compareTo(y)。 compareTo(Object)所有规则都必须遵循与实现接口方法的规则完全相同的方式 Comparable。 Comparator可以在任何需要排序的地方使用。在这种情况下，首先出现了必要的灵活性——实现多个排序规则的能力。其次，被排序的对象可能不实现 Comparable. 如果他们确实实施了， Comparator则具有优先权。该接口 Comparator还定义了一个方法 equals(Object)，这看起来很矛盾。此方法比较接口实例本身，并且仅当被比较的对象提供相同的排序顺序时才 Comparator应返回 true 。但是，保持原始实现 Object.equals(Object)不变 始终是安全的 来源：

3. Collections类有哪些方法？

public static <T> boolean addAll(Collection<? super T> c, T... elements) 该方法将数组元素添加 elements到集合中 Collection<? super T> c。元素可以单独指定或作为数组指定。当单独指定元素时，此方法提供了将所有元素方便地添加到现有集合中的功能： Collections.addAll(flavors, "Peaches 'n Plutonium", "Rocky Racoon"); public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 两种方法都使用二分搜索算法在参数中传递的列表中搜索参数中传递的对象。如果列表中存在该元素，则返回该元素的索引，否则返回列表中第一个大于 的元素的索引 key，如果所有元素都小于 key，则返回 list.size()。在使用这些方法之前，必须对列表进行排序。在第一种情况下，它们按照列表元素的“自然”顺序升序排序（与使用时相同 Collections.sort(list)）。在第二种情况下，列表必须按照传递的比较器提供的顺序按升序排序（与使用 Collections.sort(list, c)[此处“with”是来自所描述方法的参数的比较器]时的顺序相同） public static <E> Collection<E> checkedCollection(Collection<E> c, Class<E> type) 前言：泛型机制在语言中提供编译时类型检查。通常这已经足够了，但有时还不够。例如，我们将集合转移到我们未知的地方的库代码中，并且我们确实希望这个“第三方库”的代码不要将错误类型的元素插入到我们的集合中。这是可能的问题 1。可能的问题 2 如下。假设我们的程序向我们发出一条消息 ClassCastException ，通知我们将错误类型的元素插入到集合中。不幸的是，在插入不正确的元素后，此异常可能随时抛出，并且通常很少或根本不提供有关问题根源的信息。 使用方法方法 checkedCollection我们可以避免问题一和问题二，因为 此方法创建一个可在运行时验证的集合。使用此方法解决第二个问题：例如，我们有这个，它会掉下来 ClassCastException。 
Collection<String> c = new HashSet<String>();
上面的代码可以暂时替换为： 
Collection<String> c = Collections.checkedCollection(
         new HashSet<String>(), String.class);
当我们再次运行程序时，我们本地化将错误类型的元素插入到集合中的代码行。我认为相关方法： public static <E> List<E> checkedList(List<E> list,Class<E> type) public static <K,V> Map<K,V> checkedMap(Map<K,V> m, Class<K> keyType,Class<V> valueType) public static <E> Set<E> checkedSet(Set<E> s,Class<E> type) public static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K,V> m,Class<K> keyType,Class<V> valueType) public static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s,Class<E> type) public static <T> void copy(List<? super T> dest,List<? extends T> src) 该方法将 src 元素复制到 dest。复制元素的索引将相同。 public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) public static <T> T min(Collection<? extends T> coll,Comparator<? super T> comp) public static <T> T max(Collection<? extends T> coll,Comparator<? super T> comp) 方法按照“自然顺序”（Comparable 接口）或传递的比较器的顺序返回集合中的最小/最大元素。 如果集合不具有相同的元素， public static boolean disjoint(Collection<?> c1,Collection<?> c2) 则返回 true 。 <T> List <T> emptyList(), <K,V> Map <K,V> emptyMap(), <T> Set <T> emptySet()– 分别返回空列表、映射和集合； <T> void fill(List<? super T> list, T obj)– 用给定的元素填充列表； int frequency(Collection<?> c, Object o)– 返回给定元素在集合中出现的次数； – 返回n个 <T> List <T> nCopies(int n, T o)指定元素的列表； – 用新元素替换所有指定元素； – “反转”列表； – 将列表循环移动指定数量的元素； – 打乱列表元素； – 创建由一个元素组成的集合、列表和显示图； – 按自然顺序对列表进行排序并相应地使用； – 交换指定位置的列表元素。 资料来源： <T> boolean replaceAll(List<T> list, T oldVal, T newVal) void reverse(List<?> list) void rotate(List<?> list, int distance) void shuffle(List<?> list) <T> Set <T> singleton(T o), singletonList(T o), singletonMap(K key, V value) <T extends Comparable<? super T>> void sort(List<T> list), <T> void sort(List<T> list, Comparator<? super T> c) Comparator void swap(List<?> list, int i, int j)

4.Arrays类有哪些方法？

Arrays 类的方法的完整列表可以在文档中看到。在本摘要中，我将仅引用其中的一些内容。[翻译了文档中的方法，不幸的是我丢失了大部分翻译。真是可惜，我不想在同一件事上浪费时间，所以我将粘贴我在谷歌搜索到的内容] public static <T> List<T> asList(T... a) 生成一个基于数组的列表。数组用于列表的内部表示。这保留了列表和原始数组之间的连接：数组中的更改将反映在列表中： 
String[] a = { "foo", "bar", "baz"};
List<String> list = Arrays.asList(a);
System.out.println(list); // [foo, bar, baz]

a[0] = "aaa";
System.out.println(list); // [aaa, bar, baz]
列表中的更改将反映在数组中： 
String[] a = { "foo", "bar", "baz"};
List<String> list = Arrays.asList(a);
System.out.println(list); // [foo, bar, baz]

list.set(0, "bbb");
System.out.println(Arrays.toString(a)); // [bbb, bar, baz]
如果数组包含对象，显然数组和列表都将引用相同的实例： 
Object[] a = { new Object(), new Object(), new Object()};
List<Object> list = Arrays.asList(a);
System.out.println(a[0] == list.get(0)); // true
int binarySearch(параметры)– 一种重载方法，用于组织对基本类型和对象类型数组中的值进行二分搜索。返回第一个匹配的位置； void fill(параметры)– 用各种类型和原语的值填充数组的重载方法； void sort(parameters) – 一种重载方法，用于使用 Comparator 接口或不使用 Comparator 接口对数组或其一部分进行排序； static <T> T[] copyOf(T[] original, int newLength)– 填充一定长度的数组，必要时丢弃元素或填充 null； static <T> T[] copyOfRange(T[] original, int from, int to)– 将数组的指定区域复制到新数组； <T> List<T> asList(T… a)– 将数组元素复制到 List<T> 类型的对象中的方法。 来源：

5. 调用 Collections.sort() 时使用的排序名称是什么？

来自文档：该实现是 Tim Peters 的 Python 列表排序 (TimSort) 的改编。此实现将列表转储到数组中，对数组进行排序，然后迭代列表并从相应的数组元素中重新加载每个列表元素。这避免了尝试直接对链表进行排序时出现的 n*n log(n) 复杂性 来自 wiki：Timsort 是一种结合了插入排序和合并排序的混合排序算法，由 Tim Peters 于 2002 年发布。Timsort 目前是 Python、OpenJDK 7 中的标准排序算法，并在 Android JDK 1.5 中实现。该算法的主要思想是，在现实世界中，可排序的数据数组通常包含有序的子数组。在此类数据上，Timsort 比许多排序算法要快得多。

10.什么是迭代器？

Java 语言的 JDK 1.2 版本中引入的接口 java.util.Iterator允许容器类的迭代。每个迭代器都实现方法 next()，并且 hasNext()可以选择支持 remove(). 迭代器由相应的容器类创建，通常由 iterator(). 该方法 next()将迭代器前进到下一个值并将指定值返回给迭代器。最初创建时，迭代器指向第一个元素之前的特殊值，因此只有在第一次调用 next(). 为了确定容器中所有元素都被迭代的时刻，使用了测试方法 hasNext()。下面的例子演示了迭代器的简单使用： 
Iterator iter = list.iterator();
//Iterator<MyType> iter = list.iterator(); в J2SE 5.0
while (iter.hasNext())
    System.out.println(iter.next());
对于支持此功能的类型集合，迭代器方法 remove()会从容器中删除最后一个“访问”的元素。迭代期间几乎所有其他类型的容器修改都是不安全的。此外，for java.util.Listcontains java.util.ListIterator具有类似的 API，但允许向前和向后迭代，提供列表中当前索引的定义并按其位置移动到元素。 来源： 第2部分
评论
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION