Java中的集合类包括ArrayList、LinkedList、HashMap等，下列关于集合类描述错误的是（C）

A.ArrayList和LinkedList均实现了List接口

B.ArrayList的访问速度比LinkedList快

C.随机添加和删除元素时，ArrayList的表现更佳

D.HashMap实现Map接口，它允许任何类型的键和值对象
答案解析:
A.ArrayList和LinkedList都实现List接口，Hashset实现Set接口
BC.Arraylist在内存中基于数组实现，可以通过为止找到地址查找快，增加删除需要修改其后面的所以元素所以慢。LinkedList在内存中基于链表存放，查找慢，修改快。
D.HashMap运行任何键值对。即使是null也是支持的

A.ArrayList和LinkedList都实现List接口，Hashset实现Set接口
BC.Arraylist在内存中顺序排放，可以通过为止找到地址查找快，增加删除需要修改其后面的所以元素所以慢。LinkedList在内存中链表存放，查找慢，修改快
D.HashMap运行任何键值对。即使是null也是支持的.

例题
（多选）Java是一门支持反射的语言,基于反射为Java提供了丰富的动态性支持，下面关于Java反射的描述，哪些是错误的：()
A. Java反射主要涉及的类如Class, Method, Filed,等，他们都在java.lang.reflet包下

B. 通过反射可以动态的实现一个接口，形成一个新的类，并可以用这个类创建对象，调用对象方法

C. 通过反射，可以突破Java语言提供的对象成员、类成员的保护机制，访问一般方式不能访问的成员

D. Java反射机制提供了字节码修改的技术，可以动态的修剪一个类

E. Java的反射机制会给内存带来额外的开销。例如对永生堆的要求比不通过反射要求的更多

F. Java反射机制一般会带来效率问题，效率问题主要发生在查找类的方法和字段对象，因此通过缓存需要反射类的字段和方法就能达到与之间调用类的方法和访问类的字段一样的效率
答案
A D F

（注：本人编程小白，利用网络上的资源自学java，以下内容是我的学习笔记及感悟，可能会有描述不准确甚至错误的情况，还请各位大佬多多指教；如果你跟我一样也是属于入门学习阶段，建议仅将以下内容作为参考，不要过度相信）
关于函数式接口：
定义：有且仅有一个抽象方法的接口
代码示例：
关于接口：
@FunctionalInterface
//强制检查是否符合函数式接口（有且仅有一个抽象方法）
public interface MyDIYlambdaInterface {
    void mymethod();//public abstract可省略
}

关于方法
//自定义的接口可作为参数
public class Demotry {
    public static void dosomething(MyDIYlambdaInterface myin){
        myin.mymethod();
    }
//实现示例：重写接口中的抽象方法
    public static void main(String[] args) {
    dosomething(()-> System.out.println("========"));
    }
}

Lambda的延迟执行
解决性能浪费问题
关于接口
@FunctionalInterface//强制检查是否符合函数式接口（有且仅有一个抽象方法）
public interface MyDIYlambdaInterface {
    String messageBuilder();
}

关于方法
public class Demotry {
  public static void log(int i,MyDIYlambdaInterface myin){
      if(i==1){
          System.out.println(myin.messageBuilder());
      }
  }

    public static void main(String[] args) {
        String a="Happy birthday ";
        String b="to ";
        String c="you";
        log(1,()->a+b+c);
    }
}

输出结果：“Happy birthday to you”
这样做的原因：
如果是常规写法，在log方法中直接sout，即使传入的int数据不符合要求，字符串也已经被拼接，但是又无法输出，就会造成浪费。

而如果将抽象方法封装在接口中，该接口作为log方法的参数，然后在主方法中调用方法时如果前一个参数符合，再重写所需操作，就可以解决这个问题。
常用的函数式接口
Supplier
java.util.function.Supplier 接口仅包含一个无参的方法： T get() 。用来获取一个泛型参数指定类型的对

象数据。
Consumer
java.util.function.Consumer ，如其名，“消费数据”，其数据类型由泛型决定。
！！！Predicate
java.util.function.Predicate

方法： boolean test(T t) ：用于判断
应用：筛选合适信息
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

public class DemoPredicate {
    public static void main(String[] args) {
        String[] array={"迪丽热巴,女","易烊千玺,男","宋威龙,男","刘诗诗,女"};
        List<String> list =Mytest(array, s-> "女".equals(s.split(",")[1]),
                s-> s.split(",")[0].length() == 4);
        System.out.println(list);
    }
    public static List<String> Mytest(String[] array,Predicate<String> one,Predicate<String> two){
        List<String> newlist=new ArrayList<>();
        for (String every:array)//遍历这个放进去的集合
        { if(one.and(two).test(every)){
                 newlist.add(every);
        }

        }
        return newlist;
    }
}

Function – java.util.function.Function<T,R> 根据T类型，得到R类型
抽象方法：apply ： R apply(T t)
例子：提取所需年龄数据字符串，转换为整型并输出
import java.util.function.Function;

public class AboutFunction {
    public static void main(String[] args) {
String goal="刘诗诗,30";
String age=goal.split(",")[1];//将年龄字符串提取出来
        System.out.println(Myadd(age,s->Integer.parseInt(s)));


    }
    public static int Myadd(String age,Function<String,Integer> fun){
return fun.apply(age);
    }


输出结果：30

java面试题29 牛客 以下关于集合类ArrayList、LinkedList、HashMap描述错误的是（）

A HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值

B ArrayList和LinkedList均实现了List接口

C 添加和删除元素时，ArrayList的表现更佳

D ArrayList的访问速度比LinkedList快

蒙蔽树上蒙蔽果，蒙蔽树下你和我，我们先看看三者之间的一点使用规则

一、LinkedHashMap

LinkedHashMap会将元素串起来，形成一个双链表结构。可以看到，其结构在HashMap结构上增加了链表结构。数据结构为（数组 + 单链表 + 红黑树 + 双链表），图中的标号是结点插入的顺序



在这里插入图片描述

1. 类的继承关系

public class LinkedHashMap<K,V>  extends HashMap<K,V> implements Map<K,V>

LinkedHashMap继承了HashMap，所以HashMap的一些方法或者属性也会被继承；同时也实现了Map结构（HashMap原理分析

2. 类的属性，相比HashMap新增（由于继承HashMap，所以HashMap中的非private方法和字段，都可以在LinkedHashMap直接中访问）

// 链表头结点
transient LinkedHashMap.Entry<K,V> head;

// 链表尾结点
transient LinkedHashMap.Entry<K,V> tail;

// 访问顺序（可以指定accessOrder的值，从而控制访问顺序）
final boolean accessOrder;

二、ArrayList

在这里插入图片描述



 

1） 每个ArrayList实例都有一个容量，该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向ArrayList中不断添加元素，其容量也自动增长。自动增长会带来数据向新数组的重新拷贝，因此，如果可预知数据量的多少，可在构造ArrayList时指定其容量。在添加大量元素前，应用程序也可以使用ensureCapacity操作来增加ArrayList实例的容量，这可以减少递增式再分配的数量

2）    transient Object[] elementData

    底层的数据结构就是数组，数组元素类型为Object类型，即可以存放所有类型数据。我们对ArrayList类的实例的所有的操作底层都是基于数组的

3）ArrayList提供了三种方式的构造器，可以构造一个默认初始容量为10的空列表、构造一个指定初始容量的空列表以及构造一个包含指定collection的元素的列表，这些元素按照该collection的迭代器返回它们的顺序排列的

4）java 1.7之前ArrayList默认大小为10，但是1.8之后，默认是空，只有当add第一个元素时，才设置值默认值为10

5）ArrayList扩容时，正常情况下会扩容1.5倍（newCapacity = oldCapacity + (oldCapacity >> 1），特殊情况下（新扩展数组大小已经达到了最大值）则只取最大值

6）indexOf是从头开始查找与指定元素相等的元素，注意，是可以查找null元素的，意味着ArrayList中可以存放null元素的。与此函数对应的lastIndexOf，表示从尾部开始查找

7）remove函数用户移除指定下标的元素，此时会把指定下标到数组末尾的元素向前移动一个单位，并且会把数组最后一个元素设置为null，这样是为了方便之后将整个数组不被使用时，会被GC，可以作为小的技巧使用

三、LinkedList

LinkedList底层使用的双向链表结构，有一个头结点和一个尾结点，双向链表意味着我们可以从头开始正向遍历，或者是从尾开始逆向遍历，并且可以针对头部和尾部进行相应的操作

在这里插入图片描述



1. 内部类（内部类Node就是实际的结点，用于存放实际元素的地方）

private static class Node<E> {
    E item; // 数据域
    Node<E> next; // 后继
    Node<E> prev; // 前驱
    
    // 构造函数，赋值前驱后继
    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

2. 类的属性

LinkedList的属性非常简单，一个头结点、一个尾结点、一个表示链表中实际元素个数的变量。注意，头结点、尾结点都有transient关键字修饰，这也意味着在序列化时该域是不会序列化的 

3. 注意点

1）add函数用于向LinkedList中添加一个元素，并且添加到链表尾部    

2）在调用remove移除结点时，会调用到unlink函数，将指定的结点从链表中断开

3）LinkedList可以作为双端队列使用，这也是队列结构在Java中一种实现，当需要使用队列结构时，可以考虑LinkedList

四、HashSet和LinkedHashSet

1. HashSet底层是基于HashMap实现的，LinkedHashSet基于LinkedHashMap实现，所以HashSet、LinkedHashSet数据结构就是HashMap或者LinkedHashMap的数据结构

2. HashSet中由于只包含键，不包含值，由于在底层具体实现时，使用的HashMap或者是LinkedHashMap(可以指定构造函数来确定使用哪种结构)，我们知道HashMap是键值对存储，所以为了适应HashMap存储，HashSet增加了一个PRESENT类域（类所有），所有的键都有同一个值（PRESENT）

3. add、contains、remove函数都是基于HashMap或者LinkedHashMap做的操作

4. LinkedHashSet继承自HashSet，也实现了一些接口，LinkedHashSet会调用HashSet的父类构造函数，让其底层实现为LinkedHashMap，这样就很好的实现了LinkedHashSet所需要的功能

一、ArrayList 和 LinkedList：

1、区别：

（1）ArrayList是基于动态数组的数据结构，查询快，增删慢，线程不安全。

LinkedList是基于链表的数据结构，查询慢，增删快。线程不安全。

（2）对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。

（3）对ArrayList而言，主要开销是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是统一的，分配一个内部Entry对象。

（4）在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。

（5）LinkedList不支持高效的随机元素访问。

（6）ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间。

2、ArrayList和LinkedList的时间复杂度：

（1）ArrayList 是线性表：

get() 直接读取第几个下标，复杂度 O(1)；

add(E) 添加元素，直接在后面添加，复杂度O（1）；

add(index, E) 添加元素，在第几个元素后面插入，后面的元素需要向后移动，复杂度O（n）；

remove（）删除元素，后面的元素需要逐个移动，复杂度O(n)。

（2）LinkedList 是链表的操作：

get() 获取第几个元素，依次遍历，复杂度O(n)；

add(E) 添加到末尾，复杂度O(1)；

add(index, E) 添加第几个元素后，需要先查找到第几个元素，直接指针指向操作，复杂度O(n)；

remove（）删除元素，直接指针指向操作，复杂度O(1)。

3、ArrayList为什么是线程不安全的？

（1）在 Items[Size] 的位置存放此元素；

（2）增大 Size 的值：

①在单线程运行的情况下，如果 Size = 0，添加一个元素后，此元素在位置 0，而且 Size=1；

②而如果是在多线程情况下，比如有两个线程，线程 A 先将元素存放在位置 0。但是此时 CPU 调度线程A暂停，线程 B 得到运行的机会。线程B也向此 ArrayList 添加元素，因为此时 Size 仍然等于 0 （注意哦，我们假设的是添加一个元素是要两个步骤哦，而线程A仅仅完成了步骤1），所以线程B也将元素存放在位置0。然后线程A和线程B都继续运行，都增加 Size 的值。 那好，现在我们来看看 ArrayList 的情况，元素实际上只有一个，存放在位置 0，而 Size 却等于 2。这就是“线程不安全”了。

4、ArrayList能否无限添加元素？会抛异常吗？

使用ArrayList时，可以无限的往里添加元素，因为它底层是由数组实现的，使用无参构造方法时系统会默认提供默认参数10，而使用有参构造函数时我们会指定大小，当我们添加的元素个数大于数组的初始化长度时，ArrayList会自动为其扩容，扩容后的大小是int newCapacity = (oldCapacity * 3)/2 + 1;  （自动增加原来的50%）

HashMap介绍：

（1）HashMap是基于Map接口的非同步实现，结构可以看成数组+链表。

HashMap 是一个散列表，它存储的内容是键值对映射，每一个键值对也叫做Entry（Entry的组成：Key、value、next），key和value都可以为null。HashMap中的映射不是有序的。

（2）HashMap 的实现不是同步的，这意味着它不是线程安全的，后执行的线程会覆盖先执行线程的修改，在多线程环境下若使用HashMap需要使用Collections.synchronizedMap()方法来获取一个线程安全的集合。

Collections.synchronizedMap()实现原理是：Collections定义了一个SynchronizedMap的内部类，这个类实现了Map接口，在调用方法时使用synchronized来保证线程同步,当然了实际上操作的还是我们传入的HashMap实例，简单的说就是Collections.synchronizedMap()方法帮我们在操作HashMap时自动添加了synchronized来实现线程同步。

（3）HashMap 的实例有两个参数影响其性能：“初始容量” 和 “加载因子”。

        容量是哈希表中桶的数量，初始容量只是哈希表在创建时的容量，容量必须是2的N次幂，这是为了提高计算机的执行效率。加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 resize 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。（创建新表，将旧表映射到新表中）

        通常，默认加载因子是 0.75, 这是在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查询成本。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少 resize 操作次数。如果初始容量大于最大条目数除以加载因子，则不会发生 resize 操作。

（4）JDK8中HashMap的新特性:如果某个桶中的链表记录过大的话（当前是TREEIFY_THRESHOLD = 8），就会把这个链动态变成红黑二叉树，使查询最差复杂度由O(N)变成了O(logN)。

3、一些有关HashMap的问题：

（1）HashMap的get()、put()方法的工作原理？

        我们通过put()和get()方法储存和获取对象。当我们将键值对传递给put()方法时，它调用键对象的hashCode()方法来计算hashcode，让后找到bucket位置来储存Entry对象。当获取对象时，通过键对象的equals()方法找到正确的键值对，然后返回值对象。

（2）为什么String, Interger这样的wrapper类适合作为HashMap键？

        因为String是不可变的，也是final的，而且已经重写了equals()和hashCode()方法了。其他的wrapper类也有这个特点。不可变性是必要的，因为为了要计算hashCode()，就要防止键值改变，如果键值在放入时和获取时返回不同的hashcode的话，那么就不能从HashMap中找到你想要的对象。不可变性还有其他的优点如线程安全。如果你可以仅仅通过将某个field声明成final就能保证hashCode是不变的，那么请这么做吧。因为获取对象的时候要用到equals()和hashCode()方法，那么键对象正确的重写这两个方法是非常重要的。如果两个不相等的对象返回不同的hashcode的话，那么碰撞的几率就会小些，这样就能提高HashMap的性能。

正确答案: C

我是歌谣，有什么不合理之处欢迎指出。喜欢敲代码，偶尔刷刷题。

阅读目录（置顶)(长期更新计算机领域知识）

阅读目录（置顶)(长期更新计算机领域知识）

阅读目录（置顶)(长期科技领域知识）

歌谣带你看java面试题