Java 集合的扩容机制与native关键字及线程

集合的扩容机制

List 元素是有序的、可重复
ArrayList、Vector默认初始容量为10
Vector：线程安全，但速度慢
　　　　底层数据结构是数组结构
　　　　加载因子为1：即当 元素个数 超过 容量长度 时，进行扩容
　　　　扩容增量：原容量的 1倍
　　　　　　如 Vector的容量为10，一次扩容后是容量为20
ArrayList：线程不安全，查询速度快
　　　　底层数据结构是数组结构
　　　　扩容增量：原容量的 0.5倍+1
　　　　　　如 ArrayList的容量为10，一次扩容后是容量为16

Set(集) 元素无序的、不可重复。
HashSet：线程不安全，存取速度快
　　　　　底层实现是一个HashMap（保存数据），实现Set接口
　　　　　默认初始容量为16（为何是16，见下方对HashMap的描述）
　　　　　加载因子为0.75：即当 元素个数 超过 容量长度的0.75倍 时，进 行扩容
　　　　　扩容增量：原容量的 1 倍
　　　　　　如 HashSet的容量为16，一次扩容后是容量为32

Map是一个双列集合
HashMap：默认初始容量为16
　　　　　（为何是16：16是2^4，可以提高查询效率，另外，32=16<<1）
　　　　　加载因子为0.75：即当 元素个数 超过 容量长度的0.75倍 时，进行扩容
　　　　　扩容增量：原容量的 1 倍
　　　　　　如 HashSet的容量为16，一次扩容后是容量为32

native关键字

Java Native Interface (JNI)标准就成为java平台的一部分，它允许Java代码和其他语言写的代码进行交互。

JNI 的缺点：
　　①、程序不再跨平台。要想跨平台，必须在不同的系统环境下重新编译本地语言部分。
　　②、程序不再是绝对安全的，本地代码的不当使用可能导致整个程序崩溃。一个通用规则是，你应该让本地方法集中在少数几个类当中。这样就降低了JAVA和C之间的耦合性。
　　用C语言编写程序本地方法

1. 编写带有 native 声明的方法的java类，生成.java文件；
2. 使用 javac 命令编译所编写的java类，生成.class文件；
3. 使用 javah -jni java类名 生成扩展名为 h 的头文件，也即生成.h文件；
4. 使用C/C++（或者其他编程想语言）实现本地方法，创建.h文件的实现，也就是创建.cpp文件实现.h文件中的方法；
5. 将C/C++编写的文件生成动态连接库，生成dll文件；

package smiplef;
public class Hdsi {
 static
    {
        System.loadLibrary("MO");
    }
    public native void say();
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  new  Hdsi().say();
 }
}

直接运行这个代码， JVM会告之：“A Java Exception has occurred.”控制台输出如下：
Exception in thread “main” java.lang.UnsatisfiedLinkError: no MO in java.library.path
at java.lang.ClassLoader.loadLibrary(Unknown Source)
at java.lang.Runtime.loadLibrary0(Unknown Source)
at java.lang.System.loadLibrary(Unknown Source)
at smiplef.Hdsi.(Hdsi.java:6)
native
native 用来修饰方法，用 native 声明的方法表示告知 JVM 调用，该方法在外部定义，我们可以用任何语言去实现它。 简单地讲，一个native Method就是一个 Java 调用非 Java 代码的接口。
native 语法：　　
1.修饰方法的位置必须在返回类型之前，和其余的方法控制符前后关系不受限制。
2.不能用 abstract 修饰，也没有方法体，也没有左右大括号。
3.返回值可以是任意类型

线程

基本概念
进程是指运行中的应用程序，每个进程都有自己独立的地址空间(内存空间)，比如用户点击桌面的IE浏览器，就启动了一个进程，操作系统就会为该进程分配独立的地址空间。当用户再次点击左面的IE浏览器，又启动了一个进程，操作系统将为新的进程分配新的独立的地址空间。目前操作系统都支持多进程。
线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。线程有就绪、阻塞和运行三种基本状态。
线程的特点：

1. 线程是轻量级的进程
2. 线程没有独立的地址空间(内存空间)
3. 线程是由进程创建的(寄生在进程)
4. 一个进程可以拥有多个线程–>这就是我们常说的多线程编程
   线程状态
   
   多线程

多个线程实际上是交替占用CPU资源，而非我们表面看起来的并行执行。

多线程好处

1. 充分利用CPU的资源
2. 简化编程模型
3. 带来良好的用户体验
   线程的创建
   1.继承Thread类
   　　1. 编写简单，可直接操作线程
   　　2. 适用于单继承

package 线程;
public class MyThread extends Thread{
  @Override
     public void run() {
         for(int i=0;i<=20;i++){
             System.out.println(i+"线程"+
         Thread.currentThread().getName());
         }
  }
}

package 线程;
public class TreadRun {
public static void main(String[] args) {
  // TODO 自动生成的方法存根
  MyThread ma=new MyThread();
  ma.run();
  MyThread ma1=new MyThread();
  ma1.run();
 }
}

运行结果如下：
0线程main
1线程main
2线程main
3线程main
4线程main
5线程main
6线程main
7线程main
8线程main
9线程main
10线程main
11线程main
12线程main
13线程main
14线程main
15线程main
16线程main
17线程main
18线程main
19线程main
20线程main
0线程main
1线程main
2线程main
3线程main
4线程main
5线程main
6线程main
7线程main
8线程main
9线程main
10线程main
11线程main
12线程main
13线程main
14线程main
15线程main
16线程main
17线程main
18线程main
19线程main
20线程main
2.实现Runnable接口
　　1. 避免单继承局限性
　　2. 便于共享资源

package 线程;
public class Rdgvds implements Runnable{
  @Override
     public void run() {
  // TODO Auto-generated method stub
   for(int i=0;i<=10;i++){
             System.out.println(Thread.currentThread().getName()+i);
         }
  }
}

package 线程;
public class Testdus {
public static void main(String[] args) {
  // TODO Auto-generated method stub
  Rdgvds rd1=new Rdgvds();
        Thread td1=new Thread(rd1);
        td1.start();
        Rdgvds rd2=new Rdgvds();
        Thread td2=new Thread(rd2);
        td2.start();
 }
 }

运行结果如下：
Thread-00
Thread-01
Thread-02
Thread-10
Thread-11
Thread-12
Thread-03
Thread-04
Thread-05
Thread-06
Thread-07
Thread-08
Thread-09
Thread-010
Thread-13
Thread-14
Thread-15
Thread-16
Thread-17
Thread-18
Thread-19
Thread-110