java批量查询是什么意思(java 批量执行sql语句 mysql批量执行sql语句)

大家好，今天小编来为大家解答java批量查询是什么意思这个问题，java 批量执行sql语句 mysql批量执行sql语句很多人还不知道，现在让我们一起来看看吧！

java 主键重复处理

你只是为了判断主键重复吗？批量插入这种开启事务的操作，出错时就应该回滚的。你要继续插入，那这个批次的数据就不完整了吧。难道你是想在批次插入完成后再对重复主键的纪录进行处理？？？

那样的话你还不如在插入数据前，查询纪录是否存在，不存在时插入，存在时你可以进行忽略这条记录或主键修改后再插入等操作。依靠判断异常的情况不可取

希望能对你有所帮助

java 批量执行sql语句 mysql批量执行sql语句

java：sql语句批量执行

public static List>> getData{

List>> data= new LinkedList>>;

data.add(SQLHelper.executeQuery("select* from a"));

data.add(SQLHelper.executeQuery("select* from b"));

data.add(SQLHelper.executeQuery("select* from c"));

data.add(SQLHelper.executeQuery("select* from d"));

return data;

}

publicintdeleteGoodsOne(Stringgoodid,intstatus){

inti=0;

Stringsql="";

conn=db.getConn;

try{

if(status==1||status==2){

sql="updategoodssetstatus=0wheregoodid=?";

//这里想增加updaterecordsetstatus=0wheregoodid=?

}else{

sql="updategoodssetstatus=1wheregoodid=?";

//这里想增加updaterecordsetstatus=0wheregoodid=?

}

//第一次执行逻辑判断sql

ps=conn.prepareStatement(sql);

ps.setString(1,goodid);

i=ps.executeUpdate;

//第二次执行更新record表的sql

sql='updaterecordsetstatus=0wheregoodid=?';

ps=conn.prepareStatement(sql);

ps.setString(1,goodid);

i=ps.executeUpdate;

}catch(SQLExceptione){

e.printStackTrace;

}finally{

db.closeDB(conn);

}

returni;

}

使用PreparedStatement的addBatch方法添加批量sql执行，然后用executeBatch来批量执行add进去的sql

Connection con=.............;//这里是取得Lian接代码，省略

PrepareStatment ps=null;

String sql1="select* from test1";

String sql2="update test1 set xxx=1";

ps=con.prepareStatement(sql1);

ps.executeQuery(sql1);//（执行第一GeSQL）

ps.close;//记住每执行一个语句记得关闭，否Ze会出现游标错误

ps=con.prepareStatement(sql2);

ps.executeUpdate(sql2);//（执Xing第二个SQL）

ps.close;//记住每执行一个语句记得关Bi，否则会出现游标错误

con.close;//关闭连接

以上代码纯手工敲，有问题追问，Xi望能解决你的问题。

java如何执行sql语句

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

import java.sql.Statement;

public class xxxx{

public static void main(String[] args){

Connection con= null;

Statement stmt= null;

try{

Class.forName(".mysql.jdbc.Driver");//mysql为例 Bu一样的数据库所需的驱动包不一样连接语Ju略有不同

con= DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/数据库名","root","密码");

stmt= con.createStatement;

String sql="insert into info values('用Hu','mima','piapiapia~')";

stmt.executeUpdate(sql);

} catch(ClassNotFoundException e){

e.printStackTrace;

} catch(SQLException e){

e.printStackTrace;

} finally{

try{

if(stmt!= null){

stmt.close;

stmt= null;

}

if(con!= null){

con.close;

con= null;

}

} catch(SQLException e){

e.printStackTrace;

}

}

}

}

建表的时候有表确实会报错，这就看你Xiang怎么处理了。

你可以不作处Li，也就是直接用那个已经存在的表，这时SQL语句可以是这样的：create table if not exists TABLE_NAME。。

也可以把已经存在的表删掉，再Zhi行你的建表语句，这时你可以这样写：

drop table TABLE_NAME if exists;然后再

create table TABLE_NAME。。。

批了执行SQL最好的办法是采用事务Ji制。具体百度下Java事务，以下是抄来De简单例子。

publicintdelete(intsID){

dbc=newDataBaseConnection;

Connectioncon=dbc.getConnection;

try{

con.setAutomit(false);//更改JDBC事务的默Ren提交方式

dbc.executeUpdate("deletefrombylawwhereID="+sID);

dbc.executeUpdate("deletefrombylaw_contentwhereID="+sID);

dbc.executeUpdate("deletefrombylaw_affixwherebylawid="+sID);

conmit;//提交JDBCShi务

con.setAutomit(true);//恢复JDBC事务的默认提交方式

dbc.close;

return1;

}

catch(Exceptionexc){

con.rollBack;//回滚JDBC事务

exc.printStackTrace;

dbc.close;

return-1;

}

}

不过仔细看楼主的设计，没必要采用Duo条SQL。直接String拼成update XSB set XM='FF', ZF='rj' where XH='101102'就可以了

要兼容，还是分开语句吧。多写几行代Ma而已。

sql.append("create table tempTestTable(a char(4));");

sql.append("alter table tempTestTable add test"+ columnType+"(50);");

既然都是自己处理De，两句合成一句，不更方便

sql.append("create table tempTestTable(a"+ columnType+"(50)");

columnType还要看可能输入的情况

使用jdbc技术,首先导入连接数据Ku的jar包,声明加载的类名,获取连接,Jin行查询,如:

Class.forName("oracle.jdbc.driver.OracleDriver");

Connection conn= DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl","scott","tiger");

Statement sta= conn.createStatement;

ResultSet rs= sta.executeQuery("select* from tablename");

1、Connection conn= DriverManager.getConnection(URL,数据库登录Ming,数据库登录密码);//获得数据库连接。

2、Statement statement= con.createStatement;//访问数Ju库。

3、ResultSet resultSet= statement.executeQuery(sql);//执行SQL语句。

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难Yi理解的多继承、指针等概念，因此JavaYu言具有功能强大和简单易用两个特征。

技术应用

1、Android应用

许多的 Android应用都是Java程序员开发者开Fa。虽然 Android运用了不同的JVM以及不同的封装方式，但是代码还是用Java语言所编写。相当一部分的手机中都支持JAVA游戏，这就使很多非编程人员都认识LiaoJAVA。

2、在金融业应Yong的服务器程序

Java在金Rong服务业的应用非常广泛，很多第三方交易系Tong、银行、金融机构都选择用Java开发，Yin为相对而言，Java较安全[39]。Da型跨国投资银行用Java来编写前台和后Tai的电子交易系统，结算和确认系统，数据处Li项目以及其他项目。

3、网Zhan

Java在电子商务领域Yi及网站开发领域占据了一定的席位。开发人Yuan可以运用许多不同的框架来创建web项目，SpringMVC，Struts2.0Yi及frameworks。即使是简单的 servlet，jsp和以struts为Ji础的网站在***项目中也经常被用到。

4、嵌入式领域

Java在嵌入式领域发展空间很大。在这个平Tai上，只需130KB就能够使用Java技Shu。

5、大数据技术

Hadoop以及其他大数据处理技术Hen多都是用Java，例如Apache的基YuJava的HBase和AccumuloYi及 ElasticSearchas。

6、高频交易的空间

Java平台提高了这个平台的特性和即Shi编译，他同时也能够像 C++一样传递Shu据。正是由于这个原因，Java成为的程Xu员编写交易平台的语言，因为虽然性能不比C++，但开发人员可以避开安全性，可移植Xing和可维护性等问题。

7、科Xue应用

Java在科学应用中Shi很好选择，包括自然语言处理。最主要的原Yin是因为Java比C++或者其他语言相对Qi安全性、便携性、可维护性以及其他高级语Yan的并发性更好。

java集合类哪个函数可以

java集合里面的函数

java集合里面的函数_java集合【1】———从集合接口框架说起

百里方欣

原创

关注

0点赞·155人阅读

(一) java集合分类

之前大概分为三种，Set，List，Map三种，JDK5之后，增加Queue.主要由Collection和Map两个接口衍生出来,同时Collection接口继承Iterable接口，所以我们也可以说java里面的集合类主要是由Iterable和Map两个接口以及他们的子接口或者其实现类组成。我们可以认为Collection接口定义了单列集合的规范，每次只能存储一个元素，而Map接口定义了双列集合的规范，每次能存储一对元素。

Iterable接口:主要是实现遍历功能

Collection接口:允许重复

Set接口：无序，元素不可重复,访问元素只能通过元素本身来访问。

List接口：有序且可重复，可以根据元素的索引来访问集合中的元素。

Queue接口：队列集合

Map接口：映射关系，简单理解为键值对，Key不可重复，与Collection接口关系不大，只是个别函数使用到。

整个接口框架关系如下(来自百度百科)：

(1) Iterable接口

1.内部定义的方法

java集合最源头的接口，实现这个接口的作用主要是集合对象可以通过迭代器去遍历每一个元素。

源码如下：

//返回一个内部元素为T类型的迭代器(JDK1.5只有这个接口)

Iterator iterator();

//遍历内部元素，action意思为动作，指可以对每个元素进行操作(JDK1.8添加)

default void forEach(Consumer super T> action){}

//创建并返回一个可分割迭代器(JDK1.8添加)，分割的迭代器主要是提供可以并行遍历元素的迭代器，可以适应现在cpu多核的能力，加快速度。

default Spliterator spliterator(){

return Spliterators.spliteratorUnknownSize(iterator(), 0);

}

从上面可以看出，foreach迭代以及可分割迭代，都加了default关键字，这个是Java 8新的关键字，以前接口的所有接口，具体子类都必须实现，而对于deafult关键字标识的方法，其子类可以不用实现，这也是接口规范发生变化的一点。

下面我们分别展示三个接口的调用：

1.1 iterator方法

public static void iteratorHasNext(){

List list=new ArrayList();

list.add("Jam");

list.add("Jane");

list.add("Sam");

//返回迭代器

Iterator iterator=list.iterator();

// hashNext可以判断是否还有元素

while(iterator.hasNext()){

//next()作用是返回当前指针指向的元素,之后将指针移向下个元素

System.out.println(iterator.next());

}

}

当然也可以使用for-each loop方式遍历

for(String item: list){

System.out.println(item);

}

但是实际上，这种写法在class文件中也是会转成迭代器形式，这只是一个语法糖。class文件如下：

public class IterableTest{

public IterableTest(){}

public static void main(String[] args){

iteratorHasNext();

}

public static void iteratorHasNext(){

List list= new ArrayList();

list.add("Jam");

list.add("Jane");

list.add("Sam");

Iterator iterator= list.iterator();

Iterator var2= list.iterator();

while(var2.hasNext()){

String item=(String)var2.next();

System.out.println(item);

}

}

}

需要注意的一点是，迭代遍历的时候，如果删除或者添加元素，都会抛出修改异常，这是由于快速失败【fast-fail】机制。

public static void iteratorHasNext(){

List list=new ArrayList();

list.add("Jam");

list.add("Jane");

list.add("Sam");

for(String item: list){

if(item.equals("Jam")){

list.remove(item);

}

System.out.println(item);

}

}

从下面的错误我们可以看出，第一个元素是有被打印出来的，也就是remove操作是成功的，只是遍历到第二个元素的时候，迭代器检查，发现被改变了，所以抛出了异常。

Jam

Exception in thread"main" java.util.ConcurrentModificationException

at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)

at java.util.ArrayList$Itr.next(ArrayList.java:859)

at IterableTest.iteratorHasNext(IterableTest.java:15)

at IterableTest.main(IterableTest.java:7)

1.2 forEach方法

其实就是把对每一个元素的操作当成了一个对象传递进来，对每一个元素进行处理。

default void forEach(Consumer super T> action){

Objects.requireNonNull(action);

for(T t: this){

action.accept(t);

}

}

```java

当然像ArrayList自然也是有自己的实现的，那我们就可以使用这样的写法,简洁优雅。forEach方法在java8中参数是`java.util.function.Consumer`,可以称为**消费行为**或者说**动作**类型。

```java

list.forEach(x-> System.out.print(x));

同时，我们只要实现Consumer接口，就可以自定义动作，如果不自定义，默认迭代顺序是按照元素的顺序。

public class ConsumerTest{

public static void main(String[] args){

List list=new ArrayList();

list.add("Jam");

list.add("Jane");

list.add("Sam");

MyConsumer myConsumer= new MyConsumer();

Iterator it= list.iterator();

list.forEach(myConsumer);

}

static class MyConsumer implements Consumer{

@Override

public void accept(Object t){

System.out.println("自定义打印："+ t);

}

}

}

输出的结果：

自定义打印：Jam

自定义打印：Jane

自定义打印：Sam

1.3 spliterator方法

这是一个为了并行遍历数据元素而设计的迭代方法，返回的是Spliterator，是专门并行遍历的迭代器。以发挥多核时代的处理器性能，java默认在集合框架中提供了一个默认的Spliterator实现，底层也就是Stream.isParallel()实现的，我们可以看一下源码：

// stream使用的就是spliterator

default Stream stream(){

return StreamSupport.stream(spliterator(), false);

}

default Spliterator spliterator(){

return Spliterators.spliterator(this, 0);

}

public static Stream stream(Spliterator spliterator, boolean parallel){

Objects.requireNonNull(spliterator);

return new ReferencePipeline.Head<>(spliterator,

StreamOpFlag.fromCharacteristics(spliterator),

parallel);

}

使用的方法如下：

public static void spliterator(){

List list= Arrays.asList("1","2","3","4","5","6","7","8","9","10");

//获取可迭代器

Spliterator spliterator= list.spliterator();

//一个一个遍历

System.out.println("tryAdvance:");

spliterator.tryAdvance(item->System.out.print(item+""));

spliterator.tryAdvance(item->System.out.print(item+""));

System.out.println("\n-------------------------------------------");

//依次遍历剩下的

System.out.println("forEachRemaining:");

spliterator.forEachRemaining(item->System.out.print(item+""));

System.out.println("\n------------------------------------------");

// spliterator1:0~10

Spliterator spliterator1= list.spliterator();

// spliterator1:6~10 spliterator2:0~5

Spliterator spliterator2= spliterator1.trySplit();

// spliterator1:8~10 spliterator3:6~7

Spliterator spliterator3= spliterator1.trySplit();

System.out.println("spliterator1:");

spliterator1.forEachRemaining(item->System.out.print(item+""));

System.out.println("\n------------------------------------------");

System.out.println("spliterator2:");

spliterator2.forEachRemaining(item->System.out.print(item+""));

System.out.println("\n------------------------------------------");

System.out.println("spliterator3:");

spliterator3.forEachRemaining(item->System.out.print(item+""));

}

tryAdvance()一个一个元素进行遍历

forEachRemaining()顺序地分块遍历

trySplit()进行分区形成另外的 Spliterator，使用在并行操作中，分出来的是前面一半，就是不断把前面一部分分出来

结果如下：

tryAdvance:

1 2

-------------------------------------------

forEachRemaining:

3 4 5 6 7 8 9 10

------------------------------------------

spliterator1:

8 9 10

------------------------------------------

spliterator2:

1 2 3 4 5

------------------------------------------

spliterator3:

6 7

还有一些其他的用法在这里就不列举了，主要是trySplit()之后，可以用于多线程遍历。理想的时候，可以平均分成两半，有利于并行计算，但是不是一定平分的。

2. Collection接口 extend Iterable

Collection接口可以算是集合类的一个根接口之一，一般不能够直接使用，只是定义了一个规范，定义了添加，删除等管理数据的方法。继承Collection接口的有List，Set,Queue,不过Queue定义了自己的一些接口，相对来说和其他的差异比较大。

2.1内部定义的方法

源码如下：

boolean add(Object o)//添加元素

boolean remove(Object o)//移除元素

boolean addAll(Collection c)//批量添加

boolean removeAll(Collection c)//批量移除

void retainAll(Collection c)//移除在c中不存在的元素

void clear()//清空集合

int size()//集合大小

boolean isEmpty()//是否为空

boolean contains(Object o)//是否包含在集合中

boolean containsAll(Collection c)//是否包含所有的元素

Iterator iterator()//获取迭代器

Object[] toArray()//转成数组

default boolean removeIf(Predicate super E> filter){}//删除集合中复合条件的元素，删除成功返回true

boolean equals(Object o)

int hashCode()

default Spliterator spliterator(){}//获取可分割迭代器

default Stream stream(){}//获取流

default Stream parallelStream(){}//获取并行流

里面获取并行流的方法parallelStream(),其实就是通过默认的ForkJoinPool(主要用来使用分治法(Divide-and-Conquer Algorithm)来解决问题)，提高多线程任务的速度。我们可以使用ArrayList来演示一下平行处理能力。例如下面的例子，输出的顺序就不一定是1,2,3...，可能是乱序的，这是因为任务会被分成多个小任务，任务执行是没有特定的顺序的。

List list= Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

list.parallelStream()

.forEach(out::println);

2.2继承Collection的主要接口

graph LR;

Collection-->List-有顺序,可重复

List-有顺序,可重复-->LinkedList-使用链表实现,线程不安全

List-有顺序,可重复-->ArrayList-数组实现,线程不安全

List-有顺序,可重复-->Vector-数组实现,线程安全

Vector-数组实现,线程安全-->Stack-堆栈,先进后出

Collection-->Set-不可重复,内部排序

Set-不可重复,内部排序-->HashSet-hash表存储

HashSet-hash表存储-->LinkHashSet-链表维护插入顺序

Set-不可重复,内部排序-->TreeSet-二叉树实现,排序

Collection-->Queue-队列,先进先出

2.2.1 List extend Collection

继承于Collection接口，有顺序，取出的顺序与存入的顺序一致，有索引，可以根据索引获取数据，允许存储重复的元素，可以放入为null的元素。

最常见的三个实现类就是ArrayList，Vector,LinkedList，ArrayList和Vector都是内部封装了对数组的操作，唯一不同的是，Vector是线程安全的，而ArrayList不是，理论上ArrayList操作的效率会比Vector好一些。

里面是接口定义的方法：

int size();//获取大小

boolean isEmpty();//判断是否为空

boolean contains(Object o);//是否包含某个元素

Iterator iterator();//获取迭代器

Object[] toArray();//转化成为数组(对象)

T[] toArray(T[] a);//转化为数组(特定位某个类)

boolean add(E e);//添加

boolean remove(Object o);//移除元素

boolean containsAll(Collection> c);//是否包含所有的元素

boolean addAll(Collection extends E> c);//批量添加

boolean addAll(int index, Collection extends E> c);//批量添加，指定开始的索引

boolean removeAll(Collection> c);//批量移除

boolean retainAll(Collection> c);//将c中不包含的元素移除

default void replaceAll(UnaryOperator operator){}//替换

default void sort(Comparator super E> c){}//排序

void clear();//清除所有的元素

boolean equals(Object o);//是否相等

int hashCode();//计算获取hash值

E get(int index);//通过索引获取元素

E set(int index, E element);//修改元素

void add(int index, E element);//在指定位置插入元素

E remove(int index);//根据索引移除某个元素

int indexOf(Object o);//根据对象获取索引

int lastIndexOf(Object o);//获取对象元素的最后一个元素

ListIterator listIterator();//获取List迭代器

ListIterator listIterator(int index);//根据索引获取当前的位置的迭代器

List subList(int fromIndex, int toIndex);//截取某一段数据

default Spliterator spliterator(){}//获取可切分迭代器

上面的方法都比较简单，值得一提的是里面出现了ListIterator，这是一个功能更加强大的迭代器，继承于Iterator,只能用于List类型的访问，拓展功能例如：通过调用listIterator()方法获得一个指向List开头的ListIterator，也可以调用listIterator(n)获取一个指定索引为n的元素的ListIterator,这是一个可以双向移动的迭代器。

操作数组索引的时候需要注意，由于List的实现类底层很多都是数组，所以索引越界会报错IndexOutOfBoundsException。

说起List的实现子类：

ArrayList：底层存储结构是数组结构，增加删除比较慢，查找比较快，是最常用的List集合。线程不安全。

LinkedList：底层是链表结构，增加删除比较快，但是查找比较慢。线程不安全。

Vector：和ArrayList差不多，但是是线程安全的，即同步。

2.2.2 Set extend Collection

Set接口，不允许放入重复的元素，也就是如果相同，则只存储其中一个。

下面是源码方法：

int size();//获取大小

boolean isEmpty();//是否为空

boolean contains(Object o);//是否包含某个元素

Iterator iterator();//获取迭代器

Object[] toArray();//转化成为数组

T[] toArray(T[] a);//转化为特定类的数组

boolean add(E e);//添加元素

boolean remove(Object o);//移除元素

boolean containsAll(Collection> c);//是否包含所有的元素

boolean addAll(Collection extends E> c);//批量添加

boolean retainAll(Collection> c);//移除所有不存在于c集合中的元素

boolean removeAll(Collection> c);//移除所有在c集合中存在的元素

void clear();//清空集合

boolean equals(Object o);//是否相等

int hashCode();//计算hashcode

default Spliterator spliterator(){}//获取可分割迭代器

主要的子类：

HashSet

允许空值

通过HashCode方法计算获取hash值，确定存储位置，无序。

LinkedHashSet

HashSet的子类

有顺序

TreeSet

如果无参数构建Set，则需要实现Comparable方法。

亦可以创建时传入比较方法，用于排序。

2.2.3 Queue extend Collection

队列接口，在Collection接口的接触上添加了增删改查接口定义，一般默认是先进先出，即FIFO，除了优先队列和栈，优先队列是自己定义了排序的优先顺序，队列中不允许放入null元素。

下面是源码：

boolean add(E e);//插入一个元素到队列，失败时返回IllegalStateException(如果队列容量不够)

boolean offer(E e);//插入一个元素到队列，失败时返回false

E remove();//移除队列头的元素并移除

E poll();//返回并移除队列的头部元素，队列为空时返回null

E element();//返回队列头元素

E peek();//返回队列头部的元素，队列为空时返回null

主要的子接口以及实现类有：

Deque(接口):Queue的子接口，双向队列，可以从两边存取

ArrayDeque：Deque的实现类，底层用数组实现，数据存贮在数组中

AbstractQueue：Queue的子接口，仅实现了add、remove和element三个方法

PriorityQueue：按照默认或者自己定义的顺序来排序元素，底层使用堆(完全二叉树)实现，使用动态数组实现，

BlockingQueue：在java.util.concurrent包中，阻塞队列，满足当前无法处理的操作。

(2) Map接口

定义双列集合的规范Map，每次存储一对元素，即key和value。

key的类型可以和value的类型相同，也可以不同，任意的引用类型都可以。

key是不允许重复的，但是value是可以重复的，所谓重复是指计算的hash值系统。

下面的源码的方法：

V put(K key, V value);//添加元素

V remove(Object key);//删除元素

void putAll(Map extends K,? extends V> m);//批量添加

void clear()//移除所有元素

V get(Object key);//通过key查询元素

int size();//查询集合大小

boolean isEmpty();//集合是否为空

boolean containsKey(Object key);//是否包含某个key

boolean containsValue(Object value);//是否包含某个value

Set keySet();//获取所有key的set集合

Collection values();//获取所有的value的set集合

Set> entrySet();//返回键值对的set，每一个键值对是一个entry对象

boolean equals(Object o);//用于比较的函数

int hashCode();//计算hashcode

default V getOrDefault(Object key, V defaultValue)//获取key对应的Value，没有则返回默认值()

default void forEach(BiConsumer super K,? super V> action){}//遍历

default void replaceAll(BiFunction super K,? super V,? extends V> function){}//批量替换

//缺少这个key的时候才会添加进去

//返回值是是key对应的value值，如果不存在，则返回的是刚刚放进去的value

default V putIfAbsent(K key, V value){}

default boolean remove(Object key, Object value){}//移除元素

default boolean replace(K key, V oldValue, V newValue){}//替换

default V replace(K key, V value){}//替换

//和putIfAbsent有点像，只不过传进去的mappingFunction是映射函数，也就是如果不存在key对应的value，将会执行函数，函数返回值会被当成value添加进去，同时返回新的value值

default V computeIfAbsent(K key,Function super K,? extends V> mappingFunction){}

//和computeIfAbsent方法相反，只有key存在的时候，才会执行函数，并且返回

default V computeIfPresent(K key,BiFunction super K,? super V,? extends V> remappingFunction){}

//不管如何都会执行映射函数，返回value

default V compute(K key,BiFunction super K,? super V,? extends V> remappingFunction){}

default V merge(K key, V value,BiFunction super V,? super V,? extends V> remappingFunction){}

值得注意的是，Map里面定义了一个Entry类，其实就是定义了一个存储数据的类型，一个entry就是一个.

Map的常用的实现子类：

HashMap：由数组和链表组成，线程不安全，无序。

LinkedHashMap：如果我们需要是有序的，那么就需要它，时间和空间效率没有HashMap那么高，底层是维护一条双向链表，保证了插入的顺序。

ConcurrentHashMap：线程安全，1.7JDK使用锁分离，每一段Segment都有自己的独立锁，相对来说效率也比较高。JDK1.8抛弃了Segment，使用Node数组+链表和红黑树实现，在线程安全控制上使用Synchronize和CAS，可以认为是优化的线程安全的HashMap。

HashTable：对比与HashMap主要是使用关键字synchronize，加上同步锁，线程安全。

(二)总结

这些集合原始接口到底是什么？为什么需要？

我想，这些接口其实都是一种规则/规范的定义，如果不这么做也可以，所有的子类自己实现，但是从迭代以及维护的角度来说，这就是一种抽象或者分类，比如定义了Iterator接口，某一些类就可以去继承或者实现，那就得遵守这个规范/契约。可以有所拓展，每个子类的拓展不一样，所以每个类就各有所长，但是都有一个中心，就是原始的集合接口。比如实现Map接口的所有类的中心思想都不变，只是各有所长，各分千秋，形成了大千集合世界。

【作者简介】：

秦怀，公众号【秦怀杂货店】作者，技术之路不在一时，山高水长，纵使缓慢，驰而不息。个人写作方向：Java源码解析，JDBC，Mybatis，Spring，redis，分布式，剑指Offer，LeetCode等，认真写好每一篇文章，不喜欢标题党，不喜欢花里胡哨，大多写系列文章，不能保证我写的都完全正确，但是我保证所写的均经过实践或者查找资料。遗漏或者错误之处，还望指正。

平日时间宝贵，只能使用晚上以及周末时间学习写作，关注我，我们一起成长吧~

好了，文章到此结束，希望可以帮助到大家。