【概念笔记】JAVA基础 - part2

IT`huhiu前言录

这是续JAVA基础 - part1 链接http://www.cnblogs.com/ithuhui/p/5922067.html的。
笔记慢慢在修改和补充

JAVA里面重要的类

1. String

1.String 和 StringBuffer

• java.lang.String代表 不可变 的字符序列（所指向的内存区的内容永远无法修改）。

• StringBuffer提供了缓冲区，其对象是一个 可变 字符序列（可改变缓冲区的长度和内容

2.可变 不可变 字符序列的理解
String类型每进行一次操作就会new一个新对象。String a ="name"是这样子的：new一个对象，内容是“name”，放在地址A1处，让变量a指向这个A1地址。a = "age"：new一个新对象，内容是“age”，放在一个新地址A2，让变量a指向A2。结果打印出来的自然是“age”了。这个时候地址A1处的内容还是“name”，没有变（String为不可变字符串是指这个意思）。另外，这个时候地址A1处的对象（“name”）由于没有变量指向它（变量a已经指向A2），永远无法访问了所以变成了垃圾，等待系统回收

3.String的重要方法 Intern()；
public String intern()返回字符串对象的规范化表示形式
一个初始为空的字符串池，它由类String私有地维护。当调用intern()方法时，如果字符串池中已经包含一个等于此String 对象的字符串 (用equals(Object)方法确定），则返回字符串池中的字符串。否则，将此String 对象添加到字符串池中，并返回此String 对象的引用。它遵循以下规则：对于任意两个字符串s 和 t，当且仅当 s.equals(t)为true时，s.intern() == t.intern() 才为true。

2.File类

3. Enum类

4. 基本数据类型

5. Math类

JAVA I/O流

I/O流附图:

1. 按数据流的方向不同可以分为输入流和输出流
   输入流：
   输出流：
   • Reader
     
   • Writer
     
2. 按处理数据单位不同可以分为字节流（字节流：最原始的一个流，读出来的数据01010101这样去读，一个字节8位，8位8位去读）和字符流（一个字符两个字节）
3. 按功能不同可以分为节点流和处理流
   • 节点流从一个特定的数据源（节点）读写数据，如文件内存
   • 处理流是"连接"在以存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能
     
     
     
   • 转换流
     

   • 数据流
     

   • Print流
     
4. Object类I/O
   想把某个类的对象序列化必须要实现 Serializable
   序列化的程序会将对象版图上的所有东西都存储起来。被对象的实例变量所引用的对象都会被序列化。

JAVA 线程和进程

进程

进程是一个静态的概念
事实上，进程在执行指的是进程里面主线程开始执行了

线程

1. 线程是一个程序里面不同的执行路径

2. 多线程：
   -sleep()和wait()
   这两个函数都能让在休息时间内让其他线程执行。
   sleep是线程被调用时，占着cpu去睡觉，其他线程不能占用cpu，os认为该线程正在工作，不会让出系统资源，wait是进入等待池等待，让出系统资源，其他线程可以占用cpu，一般wait不会加时间限制，因为如果wait的线程运行资源不够，再出来也没用，要等待其他线程调用notifyall方法唤醒等待池中的所有线程，才会在进入就绪序列等待os分配系统资源，
   sleep是静态方法，是谁掉的谁去睡觉，就算是在main线程里调用了线程b的sleep方法，实际上还是main去睡觉，想让线程b去睡觉要在b的代码中掉sleep
   -notify()和notifyAll()
   如果对象调用了wait方法就会使持有该对象的线程把该对象的控制权交出去，然后处于等待状态。
   如果对象调用了notify方法就会通知某个正在等待这个对象的控制权的线程可以继续运行。
   如果对象调用了notifyAll方法就会通知所有等待这个对象控制权的线程继续运行。

3. 线程同步化
   • 同步方法
     即有synchronized关键字修饰的方法。
     由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，
     内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

   代码如：

   public synchronized void save(){}

   注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类

   • 同步代码块
     即有synchronized关键字修饰的语句块。
     被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

   代码如：

   synchronized(object){
   }

   注：同步是一种高开销的操作，因此应该尽量减少同步的内容。
   通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。

   代码实例：

   package com.xhj.thread;
   
   /**
    * 线程同步的运用
    *
    * @author XIEHEJUN
    *
    */
   public class SynchronizedThread {
   
       class Bank {
   
           private int account = 100;
   
           public int getAccount() {
               return account;
           }
   
           /**
            * 用同步方法实现
            *
            * @param money
            */
           public synchronized void save(int money) {
               account += money;
           }
   
           /**
            * 用同步代码块实现
            *
            * @param money
            */
           public void save1(int money) {
               synchronized (this) {
                   account += money;
               }
           }
       }
   
       class NewThread implements Runnable {
           private Bank bank;
   
           public NewThread(Bank bank) {
               this.bank = bank;
           }
   
           @Override
           public void run() {
               for (int i = 0; i < 10; i++) {
                   // bank.save1(10);
                   bank.save(10);
                   System.out.println(i + "账户余额为：" + bank.getAccount());
               }
           }
   
       }
   
       /**
        * 建立线程，调用内部类
        */
       public void useThread() {
           Bank bank = new Bank();
           NewThread new_thread = new NewThread(bank);
           System.out.println("线程1");
           Thread thread1 = new Thread(new_thread);
           thread1.start();
           System.out.println("线程2");
           Thread thread2 = new Thread(new_thread);
           thread2.start();
       }
   
       public static void main(String[] args) {
           SynchronizedThread st = new SynchronizedThread();
           st.useThread();
       }
   
   }

这里附带一篇用于理解进程和线程的，写的很好的文章，很生动！ 转载：进程和线程理解