@zhangyy 2020-12-04T09:27:47.000000Z 字数 17387 阅读 158

Java的多线程

Java基础系列

Java的多线程

一： Java的多线程

1.1 应用程序

进程：
 1. 运行时（runtime）应用程序。
 2. 进程之间的内存不是共享（独占）
 3. 进程间的通讯使用的是socket （套接字）
多线程：
 1. 进程内并发执行的代码段。
 2. 线程之间共享内存。
 3. 创建灵活响应的桌面程序
 4. 每个运行着的线程对应一个stack
 5. 应用程序至少有一个线程（主线程 main）
java.lang.Thread 
-----------------------
   1. Thread.yield()方法
   2. Thread.sleep()方法
     让当前进程休眠所需要的毫秒数

1.2 创建线程的方式：

继承Thread 类：
1. 子类覆盖父类中的run 方法，的代码存放在run 中。
2. 建立子类对象的同时线程也被创建。
3. 通过调用start 方法开启线程。

package com.learnjava.day08;
public class ThreadDemo01 {
     public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyThread m = new MyThread();
             m.start();
        YouThread y = new YouThread();
             y.start();
    }
}
// 线程 一：
class MyThread extends Thread{
     public void run() {
        for(; ;) {
            System.out.println("hello world -1");
        }
     }
}
// 线程二：
class YouThread extends Thread{
      public void run() {
         for(; ;) {
             System.out.println("hello world - 2");
         }    
      }
}

image_1bpfo2n9f1i7t1cj1jjl1v1rkk9.png-44kB

java.lang.Thread
----
1. Thread.yield()方法
让当前线程让出cpu的抢占权，具有谦让的意思，瞬时动作。
2. Thread.sleep();
  让当前线程休眠指定毫秒数。
  释放cpu 的强占权 和锁旗标没有关系
3. Thread.join()
 当前线程等待指定的线程结束后才能继续运行
 Thread t = ....
 t.join();
4.daemon 
  守护，服务员。
  为其他线程提供服务器的线程。
  若进程中剩余的线程都是守护线程的化，则进程终止了。
  Thread.setDaemon(true);
  5. ---
    原子性操作
 6.线程间通讯，共享资源的问题
   锁，防止并发访问，由并行改为串行。
   参照物的锁旗标
   // 同步代码块：
   synchronized{
       .....
   }
   同步代码块执行期间，线程始终持有对象的监控权，其他线程只能等待，处于阻塞状态。
7.同步方法是以当前所在对象做锁旗标
   synchronized(this) == 同步方法
8. 同步静态方法：使用类做为同步的标记
   public static synchronized xxx(){
   ......
   }

package com.learnjava.day08;
public class ThreadDemo02 {
        public static void main(String[] args) {
            MyThread m1 = new MyThread("Thread-1");
            MyThread m2 = new MyThread("Thread-2");
            m1.start();
            m2.start();
        }
}
class MyThread extends Thread{
    private String name ;
    public  MyThread (String name) {
        this.name = name;
    } 
    public void run() {
        for(;;) {
            System.out.println(name);
            //yield.放弃，谦让
            Thread.yield();
        }
    }
}

package com.learnjava.day08;
public class ThreadDemo03 {
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Player p1 = new Player("tom",3000);
        Player p2 = new Player("jack",2500);
        Player p3 = new Player("harry",2000);
        Player p4 = new Player("natty",1500);
        p1.start();
        p2.start();
        p3.start();
        p4.start();
        p1.join();
        p2.join();
        p3.join();
        p4.join();
        System.out.println("开局。。。。");
    }
}
class Player extends Thread {
    private String name;
    private int time;
    public Player (String name ,int time) {
        this.name = name;
        this.time = time;
    }
    public void run() {
        System.out.println(name + "出发了.....");
        try {
            Thread.sleep(time);
        } catch (Exception e) {
            // TODO Auto-generated catch block
        }
        System.out.println(name + "到了...耗时"+time);;
    }
}

package com.learnjava.day08;
public class ThreadDemo04 {
    public static void main(String[] args) {
        Box b1 = new Box("No1", 3000);
        Box b2 = new Box("No2",7000);
        Waiter w = new Waiter();
        w.setDaemon(true);
        b1.start();
        b2.start();
        w.start();
    }
}
class Box extends Thread {
    private String no ;
    private int time;
    public Box(String no ,int time) {
        this.no= no ;
        this.time = time;
    }
    public void run() {
        System.out.println(no+ "包房开始消费");
        try {
            Thread.sleep(time);
        } catch (Exception e) {
        }
        System.out.println(no + "号包房消费时间："+ time+ ",结束消费！");
    }
}
// 守护线程
class Waiter extends Thread{
    public void run() {
        while (true) {
            System.out.println(new java.util.Date());
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
            }
        }
    }
}

package com.learnjava.day08;
public class ThreadDemo05 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Saler s1 = new Saler("S1");
        Saler s2 = new Saler("S2");
        s1.start();
        s2.start();
    }
}
class  Saler extends Thread{
    static int tickets = 100;
    private String name ;
    public Saler (String name) {
        this.name = name;
    }
    public void run() {
        while (tickets >0) {
            System.out.println(name + " : " + (tickets --));
        }
    }
}

package com.learnjava.day08;
public class ThreadDemo06 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Saler s1 = new Saler("S1");
        Saler s2 = new Saler("S2");
        s1.start();
        s2.start();
    }
}
class  Saler extends Thread{
    static int tickets = 100;
    static Object lock = new Object();
    private String name ;
    public Saler (String name) {
        this.name = name;
    }
    public void run() {
        while (true) {
            int t = getTicket();
            if (t == -1) {
                return;
            }
            else {
                System.out.println(name + " : " + t);
            }
        }
    }
    // 取票
    public int getTicket() {
        // 同步代码块
        synchronized (lock) {
            int t = tickets ;
            tickets = tickets -1;
            return t <1 ? -1 : t ;
        }
    }
}

package com.learnjava.day08;
public class ThreadDemo7 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Object lock = new Object();
        Saler s1 = new Saler("S1",lock);
        Saler s2 = new Saler("S2",lock);
        s1.start();
        s2.start();
    }
}
// 售票员 
class  Saler extends Thread{
    static int tickets = 100;
     Object lock ;
    private String name ;
    public Saler (String name, Object lock) {
        this.name = name;
        this.lock = lock;
    }
    public void run() {
        while (true) {
            int t = getTicket();
            if (t == -1) {
                return;
            }
            else {
                System.out.println(name + " : " + t);
            }
        }
    }
    // 取票
    public int getTicket() {
        // 同步代码块
        synchronized (lock) {
            int t = tickets ;
            tickets = tickets -1;
            return t <1 ? -1 : t ;
        }
    }
}

package com.learnjava.day08;
public class ThreadDemo8 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TicketPool pool = new TicketPool();
        Saler s1 = new Saler("S-1", pool);
        Saler s2 = new Saler("S-2", pool);
        Saler s3 = new Saler("S-3", pool);
        s1.start();
        s2.start();
        s3.start();
    }
}
class  Saler extends Thread{
    private String name ;
    private TicketPool pool;
    public Saler (String name , TicketPool pool) {
        this.name = name;
        this.pool = pool;
    }
    public void run() {
        while(true) {
            int no = pool.getTicket();
            if(no == 0) {
                return;
            }else {
                System.out.println(name + ": " + no);
            }
        }
    }
}
// 票池
class TicketPool {
    private int tickets = 200;
    //取票
    public int getTicket() {
        // 同步代码块，以票池本身作为锁旗标
        synchronized (this) {
            int temp = tickets;
            tickets = tickets -1 ;
            return temp > 0 ? temp :0;
        }
    }
}

package com.learnjava.day08;
public class ThreadDemo8 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //TicketPool pool = new TicketPool();
        Saler s1 = new Saler("S-1");
        Saler s2 = new Saler("S-2");
        Saler s3 = new Saler("S-3");
        s1.start();
        s2.start();
        s3.start();
    }
}
class  Saler extends Thread{
    private String name ;
    public Saler (String name) {
        this.name = name;
    }
    public void run() {
        while(true) {
            int no = TicketPool.getTicket();
            if(no == 0) {
                return;
            }else {
                System.out.println(name + ": " + no);
            }
        }
    }
}
// 票池
class TicketPool {
    private  static int tickets = 100;
    public synchronized  static int getTicket() {
        // 同步代码块，以票池本身作为锁旗标
        //synchronized (this) {
            int temp = tickets;
            tickets = tickets -1 ;
            return temp > 0 ? temp :0;
    //  }
    }
}

二: Java 的集合：

list : 列表
 java.util.****
 java.util.List<Integer>list = new java.util.Arraylist();

9. wait
   让当前线程进入锁旗标的等待队列，释放cpu 抢占权 还释放锁旗标的监控权。
  解决死锁的问题方式。
  Thread.sleep() 释放cpu 的抢占权，和锁旗标没有关系。
10. notifyall() 通知所有线程可以抢占cpu和 锁旗标监控权。

image_1bppu7cvp1ems1n3l1qtd5bas32m.png-591.3kB


public class ThreadDemo9 {
    public static void main(String[] args) {
        java.util.List<Integer> list = new java.util.ArrayList<>();
        Productor p = new Productor("生产者", list);
        Consumer c = new Consumer("消费者", list);
        p.start();
        c.start();
    }
}
// 生产者
class Productor extends Thread{
    private String name ;
    private java.util.List<Integer> list;
    public Productor(String name , java.util.List<Integer>list) {
        this.name = name;
        this.list = list;
    }
    public void run() {
        int i = 0;
        while (true) {
            list.add(new Integer(i++));
        }
    }
}
//消费者
class Consumer extends Thread {
    private String name ;
    private java.util.List<Integer> list;
    public Consumer(String name , java.util.List<Integer>list) {
        this.name = name;
        this.list = list;
    }
    public void run() {
        while (true) {
            if (list.size()> 0) {
            int i = list.remove(0);
            try {
                Thread.sleep(2000);
            } catch (Exception e) {
            }
            System.out.println(name + "取出：" + i);
            }
        }
    }
}

package com.learnjava.day08;
public class ThreadDemo10 {
       public static void main(String[] args) {
           //集合：
           //java.util.List<Integer> list = new java.util.ArrayList<Integer>();
           //定义一个pool
           Pool pool = new Pool();
           Productor p = new Productor("add", pool);
           Consumer c = new Consumer("remove", pool);
           p.start();
           c.start();         
       }    
}
// 生产者
class Productor extends Thread {
    private String name ;
//  private java.util.List<Integer> list;
    private Pool pool;
    public Productor (String name ,Pool pool ) {
        this.name = name ;
        this.pool = pool ;      
    }
    public void run() {
        int i = 0;
        while (true) {
            // 增加
            // 生产比较快的方式
            pool.add(i++);
            System.out.println("add:" + i + " ");
        }       
    }
}
//消费者
class Consumer extends Thread {
    private String name ;
//  private java.util.List<Integer> list;
    private Pool pool;
    public Consumer  (String name ,Pool pool ) {
        this.name = name ;
        this.pool = pool ;
    }
    public void run() {
        while (true) {
           int i =  pool.remove();
           try {
            Thread.sleep(100);
        } catch (Exception e) {
            e.printStackTrace();
        }
           System.out.println("remove："+ i);
        }
    }
}
class Pool {
    private java.util.List<Integer> list = new java.util.ArrayList<Integer>();
    // 最大值：
    private int Max = 100;
    // 添加元素
   public void add (int n) {
     synchronized (this) {
         try {
             if(list.size() >= Max) {
                 this.wait();
             }else {
                 list.add(n);
                 this.notify();
             }
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }
    }
    // 删除元素    
    public int remove() {
        synchronized (this) {
            try {
                if(list.size() == 0) {
                    this.wait();
                }
                else {
                 int i = list.remove(0);
                    this.notify();
                    return i ;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return -1 ;
    }
}

package com.learnjava.day08;
public class ThreadDemo10 {
       public static void main(String[] args) {
           //集合：
           //java.util.List<Integer> list = new java.util.ArrayList<Integer>();
           //定义一个pool
           Pool pool = new Pool();
           Productor p1 = new Productor("add", pool);
         //  Productor p2 = new Productor("add", pool);
           Consumer c1 = new Consumer("remove", pool);
           Consumer c2 = new Consumer("remove", pool);
           p1.start();
          // p2.start();
           c1.start();
           c2.start();
       }    
}
// 生产者
class Productor extends Thread {
    int i = 0;
    private String name ;
//  private java.util.List<Integer> list;
    private Pool pool;
    public Productor (String name ,Pool pool ) {
        this.name = name ;
        this.pool = pool ;      
    }
    public void run() {
        //int i = 0;
        while (true) {
            // 增加
            // 生产比较快的方式
            pool.add(i++);
            System.out.println("add:" + i + " ");
        }       
    }
}
//消费者
class Consumer extends Thread {
    private String name ;
//  private java.util.List<Integer> list;
    private Pool pool;
    public Consumer  (String name ,Pool pool ) {
        this.name = name ;
        this.pool = pool ;
    }
    public void run() {
        while (true) {
           int i =  pool.remove();
           try {
            Thread.sleep(100);
        } catch (Exception e) {
            e.printStackTrace();
        }
           System.out.println("remove："+ i);
        }
    }
}
class Pool {
    private java.util.List<Integer> list = new java.util.ArrayList<Integer>();
    // 最大值：
    private int Max = 100;
    // 添加元素
   public void add (int n) {
     synchronized (this) {
         try {
             if(list.size() >= Max) {
                 this.wait();
             }else {
                 list.add(n);
                 System.out.println("size:" + list.size());
                 this.notify();
             }
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }
    }
    // 删除元素    
    public int remove() {
        synchronized (this) {
            try {
                if(list.size() == 0) {
                    this.wait();
                }
                else {
                 int i = list.remove(0);
                    this.notify();
                    return i ;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return -1 ;
    }
}

package com.learnjava.day08;
public class ThreadDemo11 {
       public static void main(String[] args) {
           // 创建篮子
        Basket basket = new Basket();
        for (int i = 1 ; i <=40 ; i++ ) {
            new Worker("Worker -" + i , basket).start();
        }
       }
}
// 定义工人类
class Worker extends Thread {
    private String name ;
    private static int Max = 3; // 定义工人吃馒头的最大数
    private int count ;
    private Basket basket;
    public Worker (String name , Basket basket) {
        this.name = name ;
        this.basket = basket;
    }
    public void run() {
        while (true) {
            //1.判断是否吃饱了
            if (count >=Max) {
                return;
            }
            //2. 去 取馒头
             int no = basket.getManTou();
             if (no == 0) {
                 return ;
             }
             // 3. 拿到馒头了
             count ++ ;
             System.out.println(name+ ":" +no);
        }
    }
} 
//篮子
class Basket{
   private  int count = 100 ;
   //同步方法，以当前对象做为锁旗标。
   public synchronized int getManTou() {
        int temp = count ;
        count  --;     
         return temp > 0 ? temp : 0;
   }
}

package com.learnjava.day08;
public class ThreadDemo12 {
       public static void main(String[] args) {
         HoneyPot honeypot = new HoneyPot();
         Bear b1 = new Bear("熊大", honeypot);
         Bear b2 = new Bear("熊二", honeypot);
         for(int i = 1 ; i <=100 ; i++) {
             new Bee("Bee-" + i ,honeypot).start();
         }
         b1.start();
         b2.start();
       }
}
class  Bee extends Thread{
    private String name ;
    private HoneyPot honeypot ;
    public Bee (String name,HoneyPot honeypot ) {
        this.name = name ;
        this.honeypot = honeypot;
  }
    public void run() {
        while (true) {
            int n = honeypot.add();
            System.out.println(name + "生产了蜂蜜, honeypot量：" + n);
        }
    }
}
class Bear extends Thread{
    private String name ;
    private HoneyPot honeypot ;
    public Bear (String name,HoneyPot honeypot ) {
        this.name = name ;
        this.honeypot = honeypot;
  }
    public void run() {
        while (true) {
             honeypot.remove();
            System.out.println(name + "吃掉了蜂蜜:20!");
        }
     }
    }
class HoneyPot{
    private int Max = 20 ; 
    private int count ;
    //添加 蜂蜜 +1 
  public synchronized int add () {
            while(count >= Max) {
                try {
                    this.notify();
                    this.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }               
            }
            return  ++ count ;
}
    // 移除 -20 
    public synchronized void remove() {
         while (count < Max) {
             try {
                this.wait();
            } catch (Exception e) {
                // TODO Auto-generated catch block
            //  e.printStackTrace();
            }
         }
          count = 0;
         this.notify();
    }
}

三： Runnable 方法

### 3.1 Runable 方法

 java.lang.Runnable
----
1. 接口
2. public void run();
3. 提供现有类实现线程功能；
4. 使用Runnable 对象创建线程
     new Thread(Runnable r).start()

3.2 线程的四中状态：

image_1bpuv90i9nfsk4s1aqg1m7q37rm.png-229.7kB

package com.learnjava.day08;
public class ThreadDemo13 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new Thread(new Dog()).start();
    }
}
class Animal {
    private String name;
    /**
     * @return the name
     */
    public String getName() {
        return name;
    }
    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }
}
class Dog extends Animal implements Runnable {
    public void eat () {
        System.out.println("like bone!");
    }
    public void run() {
        eat();
    }
}

3.3: IDE 集成开发环境

 IDE  集成开发环境
   integrate development environment
eclipse:
  ----
  1. 日蚀
  2. netbeans
  3. idea
  4. borland jbuilder 
  5.透视图
  6.视图
     view

3.4 线程的状态

new  // 尚未运行
runnable // 运行台
blocked // 阻塞状态等待监视器的锁定权
    Synchronized(this){}
waiting // 等待状态（无限等待）
   一个线程在等另一个线程特定的操作
timed waiting //
  限时等待，
  等待指定的时间
terminated // 
  线程退出之后终止
  sleep 
   休眠状态

image_1bpvkjtfs10hovro1vugd6v1u1i1g.png-525.9kB

image_1bqbq1ikas6u14bg10sr5ks1idb9.png-352.5kB

1、新建状态（New）：新创建了一个线程对象。
2、就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。
3、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。
4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。
（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
5、死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

3.5 String 类：

String 
 1. 常量
 2. 字符串池
 3. “abc” + "cdf"
 4. 字符有编码，charset.
 5. ide 下的默认字符集设置的就是项目编码，和字符集是一个概念
 6. 字符集
    GB2312 中文字符集
    GBK gb2312 加强版
    BIG-5 繁体字符集
    ISO-8859-1  西欧码表
    UTF-8   国际化编码，可以表示任意文字
             gbk
    ascii <  big-5        < utf-8
             iso-8859-1 
 7. 字符在内存中存储的都是unicode码
    c = '\u0098'
    c = '中'；
8. 乱码过程
    String  str = "a 中 b";
    str.getBytes();
9. 字符串遍解码：
   编码（encode） : string ---> byte[],str.getByte();
   解码(decode):byte[] --> string ,new String(byte[] ,charset)// 字符集
 10. stringBuffer 
     -1.字符串缓存区
     -2.mutable，可变的
     -3.java.lang.abstractStringBulder
        ---java.lang.StringBuffer
    -4.字符串安全的方法
StringBuilder :
------
1. 字符串构建器
2. mutable 可变的
3. java.lang.AbstractStringBuilder{  char[] value}
        --- java.lang.StringBuilder
4.不是线程安全的。
Java的基本数据类型：
---
1. 数字 
   byte     Byte
   short    Short
   int      Integer
   long     Long
   float    Float
   double   Double
2. boolean  Boolean
3. char     Character
bulider 模式
------
 1. java 设计模式之一
包装类与基本数据类型的区别
----
1. 基本数值类型的默认值是 0 
2. 包装类的默认值是null
3. 基本类型无法表达null 的概念
4. 基本类型不是对象
5.包装类是对象
6. 参与运算
   基本类型可以直接参与运算
   包装类是对象，不能直接参与运算。
   Integer a = new Integer(12);
   Integer b = new Integer(13);
   a.intValue() + b.intValue() ; //自动拆箱
   a.intValue() + b.intvalue(); 
   int i = 6 ,j =7 ;
   i+j;
   包装
自动装箱：
----
   将基本类型自动转换成包装类对象
自动拆箱
----
   将包装类对象自动转换成基本类型
-----  
1. java.lang.String 
2. java.lang.Integer
3. 常量
   String name = "xxxx";
   name = "ddd"
   for (i < 10000){
   name = name + "" + i;
   }
   byte b = (int) 1234;
   String str = 123 + " ";
   Object o = new Dog();
   Dog d = (Dog)o ;
4. 创建String 区别
// 一个对象
  String str1 = " abc";
// 两个对象
  String str2 = new String(abc);
5.split();
切割字符串，形成String数组
“hello world” ，“abc” .split (","); 最后的，不生效
6.String.substring(); 
子串
//beginIndex : int 
// endindex : int
“hello world”.substring(beginIndex,endIndex);
"hello world".substring(6,10);
// 包头不包尾

package com.learnjava.day08;
public class StringDemo01 {
    public static void main(String[] args) {
        String str0 = 123 +  " " ;
        String str = "Hello world world";
        //串长度,字符的个数
        System.out.println(str.length());
        str = "hello world中 ";
        System.out.println(str.length());
        //指定输出那一个 str.charAt(i)
        System.out.println(str.charAt(0));
        //全部输出
        for(int i = 0 ; i<str.length() ; i++ ) {
            System.out.println(str.charAt(i));
        //复制String中的[],产生新的数组，不会影响原来的数组
            char []  arr = str.toCharArray();
        //返回字符串在母串中的位置（索引值，以0 为基础）
        // 指定开始的位置  
            int pos = str.indexOf("world",7);
            System.out.println(pos);
            String s1 = "3Month";
            String s2 = "3Year";
            String s3 = "3Day";
            //判断是以指定的字符结尾：
            System.out.println(s1.endsWith("th"));
            //判断是以指定的字符开头
            System.out.println(s2.startsWith("3"));
            str = " hello world";
            String [] strr = str.split(" ");
            System.out.println(strr.length);
        }
    }
}

3.6编码表

  1.ascll 美国标准信息交换码。
     用一个字节的7 位 可以表示
  2. iso 8859-1: 拉丁码表，欧洲码表
  用一个之间的8位表示，无法存储杭州，或者只取了汉子的半。
  使用？ 代替，即编码为63.
  3. GB2312： 中国的中文编码表
  4. GBK： 中过的中午编码表升级，融合了更多的中文文字符号。
  5.unicode: 国际标准吗，融合了多种文字。
     所有文字都用两个字节来表示，Java 语言使用的就是unicode 
  6. utf-8： 醉多用三个字节来表示一个字符

package com.learnjava.day08;
import java.io.UnsupportedEncodingException;
public class ZiFu {
     public static void main(String[] args) throws  Exception  {
         char a = 97;
         a = 'a';
         a= '\uFFFF';
         int ii =5;
         String str = "a 中 b";
         byte [] bytes = str.getBytes("GBK");
         System.out.println(bytes.length);
        String NewStr = new String(bytes,"GBK");
        System.out.println(NewStr);
    }
}

3.7 集合数据

数组：
---
1. 元素 类型 必须相同
2. 长度固定
3. 地址连续
4. 通过下标，以0为基址
5. null指针异常、索引越界异常

集合
1.容器
2. 长度可变
3. 只能存放对象
4. 元素可以不相同
5. 集合都是在类当中
list 
----
 interface  java.lang.Iterable
   /|\
    | ----java.util.collection
              /|\ 
               | --- interface java.util.list 
               /|\
                | --- class java.util.ArryList
 2.可以存放重复元素
 3. 元素存放时有序
 4. Arrylist 查询块
    慢读取
    list.add ()
    list.get(int index)
    list.remove(int index)
    list.clear();
5. likedList
   链表
   通过手拉手实现对象引用
   存储速度快，查询慢
 set 
 -----
interface  java.lang.Iterable
   /|\
    | ----java.util.collection
              /|\ 
               | --- interface java.util.set 
2. 元素不能重复
3. 元素的存储是无序
常用三种集合：
  ArrayList
  HashSet
  HashMap
 没有一个是线程安全的
 list接口中常用类
 1. Vector : 线程安全，但速度慢，已经被ArrayList 取代
 2. ArrayList: 线程不安全，查询速度快。
 3. LinkedList: 链表结构，增删速度快
 取出list 集合中元素的方式：
    - get (int index)
    - iterator(); 通过迭代方法获取迭代器取对象。
string 
----
1. == 判断的是对象的内存地址，不是内容
equals
---
1. 判断对象的内容是不是相同。

集合框架的构成分类
image_1bqcg1kle189h1s0shmekjo542g.png-1023.3kB

package com.learnjava.day10;
public class Person {
    private String name ;
    private int age ;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

package com.learnjava.day10;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class PersonDemo01 {
    public static void main(String[] args) {
    List<Person> list = new ArrayList<Person>();
    Person p = null;
    for(int i = 0 ; i<100 ; i++) {
        p = new Person();
        p.setName("tom" + i);
        p.setAge(i%100);
        list.add(p);    
    }
      Iterator<Person> it = list.iterator();
      while(it.hasNext()) {
          Person p1 = it.next();
          System.out.println("Person{" + p1.getName() + "," + p1.getAge() + "}");
      }
    }
}

image_1bqekj95javh1jmu1qf7akpp0o9.png-51.3kB

package com.learnjava.day10;
import java.util.LinkedList;
import java.util.List;
public class LinkedListDemo01 {
    public static void main(String[] args) {
        List<String> list = new LinkedList<String>();
        list.add("hadoop");
        list.add(0, "spark");
        list.add("hive");
        for(int i = 0 ; i <list.size() ; i++ ) {
            System.out.println(list.get(i));
        }
    }
}

package com.learnjava.day10;
public class StringDemo01 {
     public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "abc";
        String s3 = new String("abc");
        String s4 = new String("abc");
        Person p1 = new Person("tom",1);
        Person p2 = new Person("tom",1);
        System.out.println(s1==s2);
        System.out.println(s3==s4);
        System.out.println(s3.equals(s4));
        System.out.println(p1 == p2);
        System.out.println(p1.equals(p2));
    }
}

image_1bqevp0791jc2ea811bp1hhd1o3r33.png-34.8kB