Java学习笔记（2）Java语言进阶

1、Java集合类详解

---

Collection接口：

1. 集合可以理解为一个动态的对象数组，不同的是集合中的对象内容可以任意扩充。
2. 集合的特点：1、性能高。 2、容易扩展和修改。
3. Collection的常用子类： List Set Queue

List接口：

1. List接口可以存放任意的数据，而且在List接口中的内容是可以重复的。
2. List接口常用子类： ArrayList 和 Vector 。
3. 常用操作：（1）、判断集合是否为空：Boolean isEmpty（）（2）、查找指定对象是否存在：int indexOf（Object o）。若存在，返回值为元素所在位置序列号。若不存在，返回值为-1。

ArrayList与Vector的区别：

比较 ArrayList Vertor 推出时间 JDK1.2之后推出 JDK1.0推出 性能 采用异步处理方式，性能高 采用同步处理方法，性能低 线程安全 属于非线程安全 属于线程安全

例如：

package java进阶;import java.util.ArrayList;import java.util.List;public class List接口 {    public static void main(String[] args) {        List<String> lists = null;        lists = new ArrayList<String>();        lists.add("A");  //添加元素        lists.add("B");        lists.add("A");        for (int i = 0; i < lists.size(); i++) {            System.out.println(lists.get(i));        }        lists.remove(0); //删除指定序列号元素        System.out.println("删除之后---");        for (int i = 0; i < lists.size(); i++) {            System.out.println(lists.get(i));        }        System.out.println("集合是否为空："+lists.isEmpty());//查看集合是否为空        System.out.println("B是否存在："+lists.indexOf("B"));        //查找指定对象是否存在：int indexOf（Object o）。若存在，返回值为元素所在位置序列号。若不存在，返回值为-1。           }}程序执行结果：  A  B  A  删除之后---  B  A  集合是否为空：false  B是否存在：0 

Set接口：

1. Set接口中不能加入重复元素，但可以排序。
2. Set接口常用子类：（1）散列存放：HashSet。（2）有序存放：TreeSet.

例如：

package java进阶;import java.util.HashSet;import java.util.Set;import java.util.TreeSet;public class Set接口 {    public static void main(String[] args) {        Set<String> s = new HashSet<String>();        s.add("E");        s.add("A");        s.add("D");        s.add("C");        s.add("B");        System.out.println(s);//不保证按顺序存放        TreeSet<String> s1 = new TreeSet<String>();        s1.add("E");        s1.add("A");        s1.add("D");        s1.add("C");        s1.add("B");        System.out.println(s1);//保证按顺序存放    }}

Iterator接口：

1. 集合输出的标准操作： 标准做法，使用Iterator接口。
2. 操作原理：Iterator是专门的迭代输出接口，迭代输出就是讲元素一个个进行判断，判断其是否有内容，如果有内容则把内容取出。

其接口下定义如下：

public interface Iterator {  　　boolean hasNext();  　　Object next();  　　void remove();  }  

其中：

• ​ Object next()：返回迭代器刚越过的元素的引用，返回值是Object，需要强制转换成自己需要的类型
• ​ boolean hasNext()：判断容器内是否还有可供访问的元素
• ​ void remove()：删除迭代器刚越过的元素

​ 对于我们而言，我们只一般只需使用next()、hasNext()两个方法即可完成迭代。如下：

for(Iterator it = c.iterator(); it.hasNext(); ) {  　　Object o = it.next();  　　 //do something  }  

例如：

package java进阶;import java.util.ArrayList;import java.util.Iterator;import java.util.List;public class 迭代输出Iterator接口 {    public static void main(String[] args) {        List<String> lists = null;        lists = new ArrayList<String>();        lists.add("A");  //添加元素        lists.add("B");        lists.add("C");        lists.add("D");        lists.add("E");        Iterator<String> iter = lists.iterator();//迭代接口实例化        while (iter.hasNext()) {            String str = iter.next();            if("A".equals(str)) {                iter.remove();  //删除A            }else {                System.out.println(str);            }        }    }}程序执行结果：  B C D E 

Map接口：

• Map用于保存具有映射关系的数据（key-vlaue）。Map的key不允许重复，即同一个Map对象的任何两个key通过equals方法比较总是返回false
• Collection 接口是保存单值最大的父接口，那么 Map接口保存的内容是一对值，所有的内容是以：key->value 的形式保存的。
• 常用子类：（1）HashMap：无序存放，key不允许重复。（2）Hashtable：无序存放，key不允许重复.

HashMap与Hashtable的区别：

区别点 HashMap Hashtable 推出时间 在JDK1.2之后推出的，属于新的类 在JDK1.0是推出的，属于旧的类 操作 采用异步的出来操作 性能相对较低 性能 性能高 性能相对较低 安全 非线程安全的操作 线程安全

Map接口中定义如下方法：

方法 描述 void clear() 删除Map对象中所有key-value对。 boolean containsKey(Object key) 查询Map中是否包含指定key，如果包含则返回true。 boolean containsValue(Object value) 查询Map中是否包含一个或多个value，如果包含则返回true。 Set entrySet() 返回Map中所有包含的key-value对组成的Set集合，每个集合元素都是Map.Entry(Entry是Map的内部类）对象。 Object get(Obejct key) 返回指定key所对应的value；如果此Map中不包含key，则返回null。 boolean isEmpty(): 查询该Map是否为空（即不包含任何key-value对），如果为空则返回true。 Set keySet() 返回该Map中所有key所组成的set集合。 Object put(Object key, Object value) 添加一个key-value对，如果当前Map中已有一个与该key相等的key-value对，则新的key-value对会覆盖原来的key-value对。 Object remove(Object key) 删除指定key对应的key-value对，返回被删除key所关联的value，如果该key不存在，返回null。 int size() 返回该Map里的key-value对的个数。 Collection values() 返回该Map里所有value组成的Collection。

例如：

package java进阶;import java.util.Collection;import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Set;public class Map接口 {    public static void main(String[] args) {        Map<String, String> map = new HashMap<String,String>();        map.put("key1", "A"); //添加数据        map.put("key2", "B");        map.put("key3", "C");        map.put("key4", "D");        map.put("key5", "E");        String str = map.get("key1");        System.out.println(str); //通过键值找到对应值        if (map.containsKey("key1")) {  //判断键是否存在            System.out.println("key1存在");        }else {            System.out.println("key1不存在");        }         if (map.containsValue("A")) {  //判断值是否存在            System.out.println("A存在");        }else {            System.out.println("A不存在");        }        Set<String> s = map.keySet(); //将所有键打印出来        Iterator<String> i = s.iterator();        while (i.hasNext()) {            System.out.println(i.next());        }        Collection<String> c = map.values();//将所有值打印出来        Iterator<String> i1 = c.iterator();        while (i1.hasNext()) {            System.out.println(i1.next());        }    }}

---

2、Java本地文件操作

---

文件的创建、重命名、删除：

package java进阶;import java.io.File;import java.io.IOException;public class 文件的基本操作 {    //文件夹结果必须处于同一分区    //文件夹处于不同的分区，需要使用文件的拷贝。而不是重命名    public static void main(String[] args) {        File  file = new File("hello.txt");        //判断文件是否存在        if(file.exists()) {            File nameto = new File("new hello");            file.renameTo(nameto); //文件重命名        }else {            System.out.println("文件不存在");            try {                file.createNewFile(); //如果文件不存在创建新文件                System.out.println("文件已经成功创建");            } catch (IOException e) {                System.out.println("文件无法创建");            }        }        System.out.println(file.isFile());        System.out.println(file.isDirectory());        file.delete();        System.out.println("文件已删除");    }}

文件夹的创建、重命名、删除：

package java进阶;import java.io.File;public class 文件夹的基本操作 {    public static void main(String[] args) {        File folder = new File("my new folder/two/three/main");        if (folder.mkdirs()) {            System.out.println("文件夹创建成功");        }else {            if (folder.exists()) {                System.out.println("文件夹已经存在无需创建");            }else {                System.out.println("文件创建失败");            }        }        File newfolder = new File("my new folder-new/one/two");        if (folder.renameTo(newfolder)) {            System.out.println("文件夹重命名成功");        }else {            if (newfolder.exists()) {                System.out.println("文件夹已经重命名成功");            }else {                System.out.println("文件夹重命名失败");            }        }        //只能删除空文件夹        if (newfolder.delete()) {            System.out.println("文件夹删除成功");          }else {            System.out.println("文件夹删除失败");        }               }}

获取文件的属性：

package java进阶;import java.awt.geom.FlatteningPathIterator;import java.io.Filepublic class 获取文件属性 {    public static void main(String[] args) {        File file = new File("new hello");//      判断文是否存在        System.out.println("判断文是否存在:"+file.exists());//      读取文件名称        System.out.println("读取文件名称:"+file.getName());//      读取文件路径        System.out.println("读取文件路径:"+file.getPath());//      读取文件绝对路径        System.out.println("读取文件绝对路径:"+file.getAbsolutePath());//      读取文件父级路径        System.out.println("读取文件父级路径:"+ new File(file.getAbsoluteFile().getParent()));//      读取文件大小        System.out.println("读取文件大小:"+ file.length()+"Byte");//      判断文件是否被隐藏        System.out.println("判断文件是否被隐藏:"+file.isHidden());//      判断文件是否可写        System.out.println("判断文件是否可写:"+file.canWrite());//      判断文件是否可读        System.out.println("判断文件是否可读:"+file.canRead());//      判断文件是否为文件夹        System.out.println("判断文件是否为文件夹:"+file.isDirectory());    }}程序执行结果：  判断文是否存在:true  读取文件名称:new hello  读取文件路径:new hello  读取文件绝对路径:D:\我的软件\eclipse\java学习\new     hello  读取文件父级路径:D:\我的软件\eclipse\java学习  读取文件大小:21Byte  判断文件是否被隐藏:false  判断文件是否可写:true  判断文件是否可读:true  判断文件是否为文件夹:false

文件属性的设置：

package java进阶;import java.io.File;public class 文件属性的设置 {    public static void main(String[] args) {        File file = new File("new hello");        if (file.exists()) {            //将文件设置为可写            file.setWritable(true);            //将文件设置为可读            file.setReadable(true);            //将文件设置为只读            file.setReadOnly();        }    }}

文件的遍历：

package java进阶;import java.io.File;public class 文件的遍历 {    public static void main(String[] args) {        printFiles(new File("../java学习"),1);    }    public static void printFiles(File dir,int tab) {        if (dir.isDirectory()) {            File next[] = dir.listFiles();  //返回文件的目录文件名数组            for (int i = 0; i < next.length; i++) {                for (int j = 0; j < tab; j++) {                    System.out.print("|---");                }                System.out.println(next[i].getName());                if (next[i].isDirectory()) {                    printFiles(next[i],tab+1);                }            }        }    }}

程序执行结果：

|---.classpath|---.project|---.settings|---|---org.eclipse.jdt.core.prefs|---bin|---|---java基础|---|---|---stringBuffer.class|---|---|---Switch开关语句.class|---|---|---字符串操作.class|---|---|---异常处理.class|---|---|---找最大数.class|---|---|---控制台输入.class|---|---|---数组排序.class|---|---|---逻辑运算.class|---|---java进阶|---|---|---List接口.class|---|---|---Map接口.class|---|---|---Set接口.class|---|---|---文件夹的基本操作.class|---|---|---文件属性的设置.class|---|---|---文件的基本操作.class|---|---|---文件的遍历.class|---|---|---获取文件属性.class|---|---|---迭代输出Iterator接口.class|---|---java面向对象|---|---|---A.class|---|---|---A1.class|---|---|---A2.class|---|---|---Abs.class|---|---|---Abs3.class|---|---|---B.class|---|---|---B1.class|---|---|---B2.class|---|---|---C.class|---|---|---C1.class|---|---|---Computer.class|---|---|---D.class|---|---|---Father.class|---|---|---Gener.class|---|---|---Generic.class|---|---|---Gin.class|---|---|---I.class|---|---|---Ineter1.class|---|---|---instanceof关键字.class|---|---|---Inter2.class|---|---|---Inter3.class|---|---|---Interface.class|---|---|---J.class|---|---|---People.class|---|---|---People1.class|---|---|---People2.class|---|---|---People3.class|---|---|---Person.class|---|---|---Person1.class|---|---|---PetWorker.class|---|---|---Point.class|---|---|---Printer.class|---|---|---Ref.class|---|---|---Son.class|---|---|---Student.class|---|---|---Student1.class|---|---|---Student2.class|---|---|---this关键字.class|---|---|---USB.class|---|---|---USBDesk.class|---|---|---Worker.class|---|---|---Worker2.class|---|---|---匿名对象.class|---|---|---多态性.class|---|---|---子类对象的实例化.class|---|---|---对象多态性的应用.class|---|---|---封装性.class|---|---|---引用传递.class|---|---|---抽象类.class|---|---|---抽象类的应用.class|---|---|---接口的实现.class|---|---|---接口的应用.class|---|---|---构造方法.class|---|---|---构造方法中使用泛型.class|---|---|---泛型接口.class|---|---|---泛型数组.class|---|---|---泛型方法.class|---|---|---继承.class|---|---|---继承方法的重写.class|---|---|---继承的限制.class|---|---|---认识泛型.class|---|---|---递归调用.class|---my new folder|---|---one|---|---|---two|---|---|---|---three|---|---|---|---|---main|---|---two|---|---|---three|---|---|---|---main|---my new folder-new|---|---one|---new hello|---src|---|---java基础|---|---|---stringBuffer.java|---|---|---Switch开关语句.java|---|---|---字符串操作.java|---|---|---异常处理.java|---|---|---找最大数.java|---|---|---控制台输入.java|---|---|---数组排序.java|---|---|---逻辑运算.java|---|---java进阶|---|---|---List接口.java|---|---|---Map接口.java|---|---|---Set接口.java|---|---|---文件夹的基本操作.java|---|---|---文件属性的设置.java|---|---|---文件的基本操作.java|---|---|---文件的遍历.java|---|---|---获取文件属性.java|---|---|---迭代输出Iterator接口.java|---|---java面向对象|---|---|---instanceof关键字.java|---|---|---this关键字.java|---|---|---匿名对象.java|---|---|---多态性.java|---|---|---子类对象的实例化.java|---|---|---对象多态性的应用.java|---|---|---封装性.java|---|---|---引用传递.java|---|---|---抽象类.java|---|---|---抽象类的应用.java|---|---|---接口的实现.java|---|---|---接口的应用.java|---|---|---构造方法.java|---|---|---构造方法中使用泛型.java|---|---|---泛型接口.java|---|---|---泛型数组.java|---|---|---泛型方法.java|---|---|---继承.java|---|---|---继承方法的重写.java|---|---|---继承的限制.java|---|---|---认识泛型.java|---|---|---递归调用.java

文件的简单读写：

package java进阶;import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStream;import java.io.OutputStreamWriter;import java.io.UnsupportedEncodingException;public class 文件的简单读写 {    public static void main(String[] args) {        File file = new File("hello word");        //如果文件不存在，文件输出流会自动创建文件        //写文件        try {            FileOutputStream fos = new FileOutputStream(file); //创建文件输出流            OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");//创建输出流            BufferedWriter bw = new BufferedWriter(osw); //创建缓冲区的write            bw.write("hello word!\n");//向文件写入“hello word！”            bw.close();//关闭流            osw.close();            fos.close();            } catch (FileNotFoundException e) {            e.printStackTrace();        } catch (UnsupportedEncodingException e) {            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        }        //读取文件        try {            FileInputStream fis = new FileInputStream(file);            InputStreamReader isr = new InputStreamReader(fis, "UTF-8");            BufferedReader br = new BufferedReader(isr);            String list;  //定义一个变量用于存放读取的数据            while ((list = br.readLine()) != null) {                System.out.println(list);            }            br.close();            isr.close();            fis.close();        } catch (FileNotFoundException e) {            e.printStackTrace();        } catch (UnsupportedEncodingException e) {            e.printStackTrace();        } catch (IOException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }               }}程序执行结果：  hello word！

---

3、Java中的IO操作

---

Java IO简介：

• IO也写作“I/O”，可理解为In和Out，即输入与输出。所有，IO体系的基本功能就是：读和写。
• IO流作用：读写设备上的数据，硬盘文件、内存、键盘、网络···
• 根据数据的走向，可以分为：输入流、输出流。
• 根据处理的数据类型，可分为：字节流、字符流。

字节流与字符流：

• 字节流可以处理所有类型的数据，如MP3、图片、文字、视频等。在读取时，读到一个字节就返回一个字节。在Java中对应的类都以“Stream”结尾。
• 字符流仅能够处理纯文本数据，如txt文本等。在读取时，读到一个或多个字节，先查找指定的编码表，然后将查到的字符返回。在Java中对应的类都以“Reader”或“Writer”结尾。

字符、字节与编码的区别：

说明 举例 字符 人们使用的记号，抽象意义上的一个符号。 字节 计算机中的存储数据的单元，一个8位的二进制大数，是一个很具体的存储空间。 ANSI编码 系统预设的标准文字存储格式，不是具体的某一种编码，不同的国家和地区使用不同的标准。ANSI编码的一个字符可能使用一个字节或多个字节来表示。 Unicode编码 为了是国际间信息交流更加方便，国际组织制定了Unicode字符集，为各种语言中的每一个字符设定了统一并且唯一的数字编码，以满足跨语言、跨平台进行文本转换、处理的要求。 字符集（Charset） 字符集，也称作“编码”。

使用文件流读写文件：

package java进阶;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;public class 使用字节流读写数据 {    public static void main(String[] args) {        try {            FileOutputStream fos = new FileOutputStream("hello word1");            FileInputStream fis = new FileInputStream("hello word");            byte input[] = new byte[30]; //定义读取文件存放位置            fis.read(input);   //读文件            String inputString = new String(input);            System.out.println(inputString);//输出文件内容            fos.write(input);  //写入新的文件，实现文件的复制            fos.close();  //关闭流            fis.close();            } catch (FileNotFoundException e) {            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        }    }}

4、Java多线程编程:

---

线程与进程：

• 线程：程序中单独顺序的控制流。特点：（1）线程本身依靠程序进行运行。（2）线程是程序中的顺序控制流，只能使用分配给程序的资源和环境。
• 进程：执行中的程序。（1）一个进程可以包含一个或多个线程。（2）一个进程至少要包含一个线程。
• 单线程：程序中只存在一个线程，实际上主方法就是一个主线程。
• 多线程：（1）多线程是一个程序中运行多个任务。（2）多线程的母的是为了更好的使用CPU资源。

线程的实现：

1. 在Java中，线程的实现有2种。（1）继承Thread类。（2）实现Runnable接口。

2. Thread类：是在Java.lang包中定义的，继承Thread类必须重写run（）方法。定义格式：

3. class className extends Thread{   run（）{}；}

4. Runnable接口

例如：

通过继承Thread类实现线程：

package java进阶;//通过继承Thread类实现线程public class MyThread extends Thread{    private String name;    public MyThread(String name) {   //构造方法用于传参        this.name = name;    }    public void run() {        for (int i = 0; i < 1000; i++) {            System.out.println(name+":"+i);        }        super.run();    }}

通过Runnable接口实现线程：

package java进阶;//通过Runnable接口实现线程public class MyRunnable implements Runnable{    private String name;    public MyRunnable(String name) {        this.name = name;    }    public void run() {        for (int i = 0; i < 1000; i++) {            System.out.println(name+":"+i);        }    }}

用过主函数调用方法:

package java进阶;public class 线程主函数 {    public static void main(String[] args) {        //通过Thread方法实现线程        MyThread t1 = new MyThread("A");        MyThread t2 = new MyThread("B");        t1.start(); //线程的启动时通过start        t2.start();        //通过Runnable实现线程        MyRunnable r1 = new MyRunnable("C");        MyRunnable r2 = new MyRunnable("D");        Thread t3 = new Thread(r1);        Thread t4 = new Thread(r2);        t3.start();        t4.start();    }}

线程的状态：

线程有固定的操作状态：

• 创建状态：准备好了一个多线程的对象。
• 就绪状态：调用start（）方法，等待CPU进行调度。
• 运行状态：执行run（）方法。
• 阻塞状态：暂时停止执行，可能将资源交给其他线程使用。
• 终止状态（死亡状态）: 线程销毁。

线程的常用方法：

1. 取得线程名称：getName();
2. 取得当前线程对象：currentThread();
3. 判断线程是否启动：isAlive();
4. 线程的强行运行：join();
5. 线程的休眠：sleep();
6. 线程的礼让：yield();

例如：

package java进阶;class Thread1 extends Thread{    private String name;    public Thread1(String name) {        this.name = name;    }    public void run() {        for (int i = 0; i < 50; i++) {            System.out.println(name+":"+i);            if (i == 10) {                System.out.println("礼让");                Thread.yield();            }            try {                Thread.sleep(10); //线程的休眠            } catch (InterruptedException e) {                e.printStackTrace();            }        }        //取得当前线程对象        System.out.println(Thread.currentThread());        //取得当前线程名称        System.out.println(Thread.currentThread().getName());        super.run();    }}public class 线程的常用方法 {    public static void main(String[] args) {        Thread1 t1 =new  Thread1("A");        Thread1 t2 =new  Thread1("B");        //判断线程是否启动        System.out.println(t1.isAlive());        t1.start();        for (int i = 0; i < 50; i++) {            if (i > 10) {                try {                    t1.join(); //线程的强制执行                } catch (InterruptedException e) {                    e.printStackTrace();                }            }            System.out.println("主线程："+i);        }        t2.start();        System.out.println(t1.isAlive());    }}

线程优先级：

• MIN_Priority—1
• MAX_Priority—10

• NORM——Priority—5. 默认值为5

• 注意：线程优先级不是一定按优先级执行。而是提高了执行概率。

t1.setPtiority(Thread.MIN_PRIOITY);

同步与死锁：

1. 同步代码块：在代码块上加上“synchronized”关键字，则此代码块就称为同步代码块。

2. 同步代码块格式：

3. synchronized(同步对象){ 需要同步的代码块；}

4. 同步方法：除了代码块可以同步，方法也可以同步。

5. 方法同步的格式：synchronized void 方法名称（）{}

6. 同步实现了资源的共享。

死锁：死锁是两个甚至多个线程被永久阻塞时的一种运行局面，这种局面的生成伴随着至少两个线程和两个或者多个资源。

package java进阶;//三个窗口卖一辆车的车票，实现数据的同步class Synchornized implements Runnable{    private int ticket = 5;    public void run() {        for (int i = 0; i < 10; i++) {        tell();        }    }    public synchronized void tell() {  //同步方法        if(ticket > 0) {            try {                Thread.sleep(500);            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println("ticket:" + ticket-- );        }    }}public class 线程的同步 {    public static void main(String[] args) {        Synchornized s = new Synchornized();        Thread t1 = new Thread(s);        Thread t2 = new Thread(s);        Thread t3 = new Thread(s);        t1.start();        t2.start();        t3.start();    }}

线程的生命周期：

图：线程的生命周期

---