md

创建文件夹

cd

进入文件夹

del

删除文件夹

copy

复制文件

rd

删除文件夹

cd..

后退一级

cls

清屏

help

帮助

dir

列出目录

cd\

进入根目录

ren

重命名

分类

不同类型

关键字

字节数

取值范围

默认值

整数型

字节型

byte

1个字节

-2⁷~2⁷-1（-128~127）

0

短整型

short

2个字节

-2¹⁵~2¹⁵-1（-32768~32767）

0

整型

Int (默认)

4个字节

-2³¹~2³¹-1

0

长整型

long

8个字节

-2⁶³~26³-1

0

文本型

字符型

char

2个字节

0~2¹⁶-1（从0~65536）

‘\u0000’

浮点型

单精度浮点型

float

4个字节

大约±3.40282347E+38F

（有效位数为6~7位）

0.0f

双精度浮点型

Double

(默认)

8个字节

大约±1.79769313486231570E+308

（有效位数为15位）

0.0d

逻辑型

布尔型

boolean

1个字节

True/false

false

优先级

运  算  符

含义描述

1

( ) ，. ， [ ]

强制运算、方法调用

2

++ ， -- ， + ， ~(位取反) ， !(逻辑取反)

一元运算、字符串相加

3

New   eg.Type a=new Type()

创建运算符

4

* ， / ， %

算术运算 乘除、取余

5

+ ， -

算术运算 加减(正负)

6

<< ， >> ， >>>(无符号)

位运算

7

< ， > ， <= ， >= ， instanceof

比较运算、类运算

8

= = ， ! = ， .equals()

比较运算

9

&

逻辑(位)运算 与

10

^

位运算 异或

11

|

逻辑(位)运算 或

12

&&

逻辑 与(短路)

13

||

逻辑 或(短路)

14

?:   eg. (关系表达式)?表达式1：表达式2；

三元 条件运算

15

= ， *= ， /= ， %= ， += ， －=

简单赋值运算

16

<<= ， >>=  ， >>>= ， &= ， ^= ， |=

复杂赋值运算

If 判断：

else If 判断：

If 判断(嵌套)：

switch 判断：

if (表达式) {

       //语句1;

} else {

       //语句2;

}

类比：

(关系表达式)?

表达式1：表达式2;

注：else语句可用

Continue代替;

if (表达式1) {

       //语句1;

}

else if (表达式2) {

           //语句2;

…

}

else {

//语句3;

}

If (表达式1) {

       if（表达式2) {

              //语句1;

       } else {

              //语句2;

       }

} else {

       //语句3;

}

switch (表达式) {

case 常量1:

语句1；

break;

case 常量2:

语句2;

break;

…

default:

语句3;

}

while循环：

do-while循环：

for循环：

while(表达式) {

            //循环体;

}

do{

   //循环体;

} while(表达式);

for(初始化;条件;迭代) {

   //循环体;

}

do {

        String title = input.next();

        if (title.equals("exit")) {

       break;

        }

    } while (true); // 跳出死循环

    public static void main(String[] args) {

    int i = 0;

    do {

        i++;

        if (i == 3) {

       // break; // 输出12

       continue; // 输出1245

        }

        System.out.println(i);

    } while (i < 5);

}

    for (int i = 0; i < 10; i++) {

        if (i % 2 != 0)

       return;

        System.out.print(i);

    } // 运行结果：0

步骤

举例

解释

声明

int[ ] a;

告诉计算机数据类型是什么

分配空间

a = new int[5];

告诉计算机分配几个连续的空间

赋值

a[0] = 8;

向分配的格子里放数据

引用

a[0] = a[0] * 10;

引用数据进行计算

for (int k = array.length - 1; k >= 0; k--) {// 逆序输出

    System.out.print(array[k] + "\t");

}

for (int temp : array) {// 用for增强型函数对数组进行顺序输出

    System.out.println(temp);

}

数组的增添举例：

String[] phones = new String[] {"iPones4S", "iPones5", null};

// null 不用加双引号

int index = -1;// 增加监视器

for (int i = 0; i < phones.length; i++) {// 1.增加iPones6

    if (phones[i] == null) {

        index = i;

        break;

    }

}

    if (index != -1) {

        phones[index] = "iPones6";

    } else {

        System.out.println("数组已满");

        }

System.out.println(Arrays.toString(phones));

for (int m = 0; m < array.length - 1; m++) { // 冒泡排序

            for (int n = 0; n < array.length - 1 - m; n++) {

                if (array[n] > array[n + 1]) {

                    int temp = array[n];

                    array[n] = array[n + 1];

                    array[n + 1] = temp;

                }

            }

        }

方法名称

说明

Arrays.

boolean equals(array1,array2)

比较array1和array2两个数组是否相等

sort(array)

对数组array的元素进行升序排列

String toString(array)

将一个数组array转换成一个字符串

void fill(array,val)

把数组array所有元素都赋值为val

copyOf(array,length)

把数组array复制成一个长度为length

的新数组，返回类型与复制的数组一致

int binarySearch(array, val)

查询元素值val在数组array中的下标

（要求数组中元素已经按升序排列

    String[][] str = new String[5][];

    int[][] scores = new int[][] { { 90, 85, 54 }, { 76, 80 },{ 87 } };

    int[][] scores = { { 90, 85, 54 }, { 76, 80 }, { 87 } };

public class Case5 { // 二维数组的遍历

        public static void main(String[] args) {

            int[][] scores = new int[][] { { 90, 78, 54 }, { 76 , 80 }, { 87 } };

            for (int i = 0; i < scores.length; i++) { //外层数组长度

                for (int j = 0; j < scores[i].length; j++) {//内层数组长度

                    System.out.println(scores[i][j]);

                }

            }

        }

    }

public class ConstructorMethod {

    String name;

int age; // 成员变量

public ConstructorMethod(String name, int age) {

//有参构造方法,构造方法无返回类型

        this.name = name;                          

        this.age = age;  //实例的属性 = 实参;

}

    public static int Case1() { //成员方法

        System.out.println("我是Case1调用");

        return 0;

    }

}

public class Test {

    public static void main(String[] args) {

    Cat cat = null;  //局部变量需要初始化或传实参

    Pet pet = new Cat();

    cat = (Cat)cat;

    }

}

class Pet {

}

class Cat extends Pet {

}

public class Test {

    private String name;

    public Test(){

       this.name = "小新";

    }

    public Test(String name) {

       System.out.println("我是" +this.name);

    }

    public static void main(String[] args) {

       Test test = new Test("小强");

    }

} //运行结果：我是null（实参没有该成员变量赋值）

public class Test {

    public static void main(String[] args) {

    for (int i = 0; i < args.length; i++) {

        System.out.println("args" + i + "=" + args[i]);

    }

    }

}

输出结果：

args0=args1

args1=args2

u  int month = 4;   

u  int day = input.nextInt();

注：作为形参的变量的初始化便是传入实参。

abstract class Person {

    public abstract void eat();

}

public class Demo {

    public static void main(String[] args) {

    Person p = new Person() {

        public void eat() {

       System.out.println("eat something");

        }

    };

    p.eat();

    }

}

    static {

        System.out.println ("Hello Everyone");

        }

public class Test {

    private String name; //将类的属性进行封装

    public String getName() { //并提供可带判断条件的访问方法

        return name;

}

    public void setName(String name) {

        this.name = name;

}

}

class Person {                      // 父类

    private String name;

    public static int age;

    public static String sex;

    public Person() {              // 会自动生成无参构造器

          System.out.println("父类构造器");                        

    };                              // 但是考虑继承的可靠性，建议写上。

    public void setName(String name) {

        this.name = name;

    }

    public String getName() {

        return this.name;

    }

}

class Student extends Person {   // 子类

    private String school;

    public Student() {            // 子类student中构造

        super();                   //super只可在子类中使用

        System.out.println("子类构造器");

    }

}

public class TestExtendDemo {    // 测试类

    public static void main(String[] args) {

        Person.age = 18;

        Student.age = 19;          // 继承父类的成员属性和方法可直接调用

        Person.sex = "男";         // 静态变量或方法用类调用

        System.out.println(Student.age+Person.sex);

        Scanner input = new Scanner(System.in);

        Student someone = new Student();    //创建子类对象的过程

        someone.setName(input.next());      // 实例变量和方法用实例调用

        System.out.println(someone.getName());

    }

}

abstract class Animal { // 因为本身实例化没有意义，所以一般申明为抽象类

    Animal() {           // 会自动生成无参构造器

    };                    // 但是考虑继承的可靠性，建议写上。

    abstract void eat();//  抽象方法

}

class Cat extends Animal {      // 1、继承父类

    public void eat() {         // 2、子类方法的重写

        System.out.println("吃鱼");

    }

    public void catchMouse() {  //子类私有方法，只能用子类对象调用

        System.out.println("抓老鼠");

    }

}

class Dog extends Animal {       // 1、继承父类

    public void eat() {          // 2、子类方法的重写

        System.out.println("吃骨头");

    }

    public void kanJia() {

        System.out.println("看家");

    }

}

class DuoTaiDemo {                // 类名与源文件相同，否则无法运行

    public static void main(String[] args) {

        function(new Cat());      // new Cat() 表示构造一个猫的对象

        function(new Dog());

        //Animal a;          //对象可像变量一样声明和传递参数

        //a= new Cat();     //父类为抽象类，不能实例化，但能创建引用

        Animal a=new Cat();

        // 向上转型 // 类似变量传参，new Cat()是参数

        a.eat();      

        //3.父类对象引用指向子类对象 PS:须先满足前两个条件

    }

   public static void function(Animal a) {   //对象可作变量传递参数

        a.eat();       //3.父类对象引用指向子类对象 PS:须先满足前两个条件

        if (a instanceof Cat) {// 用于判断对象是否为指定类的实例

            Cat c = (Cat) a;    // 向下转型，由Animal(父)类转为Cat(子)类

            c.catchMouse();     // 向下转型，调用子类特有属性

        } else if (a instanceof Dog) {

            Dog c = (Dog) a;

            c.kanJia();

        }

    }

public class Polymorphism {  // 多态传参 ,取例 Think in Java

    void doStuff(Shape s) {  // 形参

    s.erase();

    // ...

    s.draw();

    }

    public static void main(String[] args) {

    Circle c = new Circle();  // Circle/Triangle/Line是Shape的子类

    Triangle t = new Triangle();

    Line l = new Line();

    doStuff(c); // 实参

    doStuff(t);

    doStuff(l);

    }

}

public abstract class ClassName {

    int name;

    abstract void fun();

}

public interface InterfaceName {

    public abstract void cry();

}

    class ClassName implements Interface1,Interface2....{

}

参数

抽象类

接口

默认的方法实现

它可以有默认的方法实现

所有的方法都是抽象的。不存在方法的实现

实现

子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。

子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现

构造器

抽象类有构造器，用于子类初始化

接口不能有构造器

普通类

除了不能实例化抽象类之外，它和普通Java类没有任何区别

接口是完全不同的类型

访问修饰符

抽象方法可以有public、protected和default这些修饰符

接口方法默认修饰符是public。不可以使用其它修饰符。

main方法

抽象方法可以有main方法并且我们可以运行它

接口没有main方法，因此我们不能运行它。

多继承

抽象方法可以继承一个类和实现多个接口

接口只可以继承一个或多个其它接口

速度

它比接口速度要快

接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法。

添加新方法

如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。

如果你往接口中添加方法，那么你必须改变实现该接口的类。

import java.util.InputMismatchException;

import java.util.Scanner;

public class TryCatch {

    public static void main(String[] args) {

    Scanner input = new Scanner(System.in);

    try {// 可能会发生异常的程序代码

        System.out.print("请输入一个数字:");

        int a = input.nextInt();

    } catch (InputMismatchException e) {// 捕捉异常

        System.err.println("数据类型不符!");

        e.printStackTrace();

        System.err.println(e.getMessage());

        // return; 若捕捉到异常会先执行finally, 再return。

    } catch (Exception e) {// catch 先写子类，再写父类

        System.out.println("再捕捉一次!");

        System.exit(1);

    } finally {// 除非执行System.exit(1)，否则都会执行

        System.out.println("finally 被执行!");

        // 应用举例：确保关闭数据库，关闭流

    }

    System.out.println("我还是被执行了!");

    // 如果提前return，则不执行了

    }

}

public class Throws {

    public static void main(String[] args) throws Exception{

    System.out.println(10 / 0);

    throw new Exception("抛出异常");

    //System.out.println("throw后面的代码不再执行");

    }

}

       上述类图中，实线边框的是实现类，比如ArrayList，LinkedList，HashMap等，折线边框的是抽象类，比如AbstractCollection，AbstractList，AbstractMap等，而点线边框的是接口，比如Collection，Iterator，List等。

返回类型

方法

解释

boolean

add(E e)

确保此 collection 包含指定的元素（可选操作）。

void

clear()

移除此 collection 中的所有元素（可选操作）。

boolean

contains(Object o)

如果此 collection 包含指定的元素，则返回 true。

boolean

isEmpty()

如果此 collection 不包含元素，则返回 true。

boolean

remove(Object o)

从此 collection 中移除指定元素的单个实例。

int

size()

返回此 collection 中的元素数。

boolean

equals(Object o)

比较此 collection 与指定对象是否相等。

Object[]

toArray()

返回包含此 collection 中所有元素的数组。

Iterator<E>

iterator()

返回在此 collection 的元素上的迭代器 (接口)。

class Arrays { // 除特殊表明，为 Collection接口所有实现类所的方法

    ArrayList<String> list = new ArrayList<String>();

    void OwMethod() {

    list.add("且听风吟_z");

    list.add("山多拉之灯");

    list.add(0, "Jake"); // 使用下标确定添加位置

    System.out.println(list.get(1)); // list 特有

    System.out.println("下标为：" + list.indexOf("Jake")); // list 特有

    System.out.println(list.set(0, "Captain")); // 替换元素, list 特有

    System.out.println("判断包含元素：" + list.contains("Captain"));

    System.out.println("该集合有元素数：" + list.size());

    System.out.println("移除元素：" + list.remove("山多拉之灯"));

    System.out.println("字符串型式返回元素：" + list.toString());

    System.out.println("这是什么鬼：" + list.toArray() + "\n");

    list.clear(); // 没有返回值

    System.out.println("\n判断是否为空：" + list.isEmpty());

    }

}

<E>

get(int index)

返回列表中指定位置的元素。

<E>

set(int index, E element)

用指定元素替换列表中指定位置的元素（可选操作）。

<E>

getFirst()

返回此列表的第一个元素。

<E>

getLast()

返回此列表的最后一个元素。

<E>

removeFirst()

移除并返回此列表的第一个元素。

class Link { // LinkedList 方法举例

    LinkedList<String> list2 = new LinkedList<String>();

    void OwMethod() {

    list2.add("No.1");

    list2.addFirst("我是第一个!");

    list2.add("No.2");

    System.out.println("LinkedList 返回元素：" + list2.getFirst());

    list2.removeFirst();

    System.out.println("LinkedList 返回元素：" + list2.toString());

    }

}

class Set { // HashSet 方法举例

    HashSet<String> list6 = new HashSet<String>();

    void OwMethod() {

    list6.add("cat");

    list6.add("dog");

    System.out.println(list6.getClass());

    }

}

返回类型

方法

解释

boolean

containsKey(Object key)

确保此 collection 包含指定的元素。

<V>

get(Object key)

返回指定键所映射的值。

<V>

put(K key, V value)

将指定的值与此映射中的指定键关联。

Collection<V>

values()

返回此映射中包含的值的 Collection集合。

Set<K>

keySet()

返回此映射中所包含的键的 Set集合。

class Map {

    HashMap<Integer, String> list7 = new HashMap<Integer, String>();

                                  // Map要得是对象，不能放int

    void OwMethod() {

    list7.put(1, "car");   // key 不可以重复

    list7.put(2, "truck"); // Value 的值可以是普通数据也可以是对象

    list7.put(3, "bus");

    System.out.println("是否包含key = 1：" + list7.containsKey(1));

    System.out.println("key所对应的值：" + list7.get(1));

    System.out.println("包含Value的所有元素：" + list7.values());

    System.out.println("包含Key的所有元素：" + list7.keySet());

    System.out.println("HashMap返回元素：" + list7.toString() + "\n");

    }

}

boolean

hasNext()

如果仍有元素可以迭代，则返回 true。

Set<K>

next()

返回迭代的下一个元素。

void

remove()

移除迭代器返回的最后一个元素。

    Collections.sort(list);  // Ps：不是必须的

    Iterator<String> iter = list.iterator(); //1.调用迭代器，遍历集合元素

    while (iter.hasNext()) {

        String name = iter.next();

        System.out.println(name);

    }

    for (String str : list) { // 2.使用增强for循环，遍历集合元素

        System.out.println(str);

    }

       // 3.转换成字符串，遍历集合元素

    System.out.println("HashMap返回元素：" + list.toString() + "\n");

Void

sort(List<T> list) 

根据自然顺序 对指定列表按升序进行排序。

<T>

Max

根据自然顺序，返回给定 collection 的最大元素。

<T>

Min

根据自然顺序，返回给定 collection 的最小元素。

<T>

Max (Comparator)

重写比较器，返回给定 collection 的最大元素。

<T>

Fill(list，obj)

使用指定元素替换指定列表中的所有元素。

<T>

binarySearch

使用二分搜索法搜索指定列表，以获得指定对象。

    Collections.sort(list);

    Iterator<Student> it = list.iterator();

    while (it.hasNext()) {

        Student stu = (Student) it.next();

        System.out.println(stu.getNumber());

    }

    int index = Collections.binarySearch(list, student1);

    System.out.println("student1的下标是：" + index);

    Student stu1 = Collections.max(list);

    System.out.println("最大值的下标是：" + stu1.getNumber());

    // Collections.fill(list, "我被替换了"); // 替换的是什么东西？？

    public int compareTo(Object obj) {

        Student student = (Student) obj;

        if (this.number == student.number) { // 用对象还是get都可以

            return 0;

        } else if (this.number > student.getNumber()) {

            return 1;

        } else {

        return -1;

        }

    }

public enum Week {

    MON, TUE, WED, THU, FRI, SAT, SUN;

}

// 调用 Week. MON

public enum FORMAT {

    YYYY_MM_DD_FORMAT("yyyy-MM-dd"), // 为枚举元素赋值先定义元素，再定义属性

    DD_MM_YYYY_FORMAT("dd-mm-yyyy");

    private String stringValue;

    private FORMAT(String stringValue) {

    this.stringValue = stringValue;

    }

    public String getStringValue() {

    return stringValue;

    }

}   // 调用 FORMAT.DD_MM_YYYY_FORMAT.getStringValue()

基本数据类型

包装类

包装类

包装类

byte

Byte

Number

Object

short

Short

int

Integer

long

Long

float

Float

double

Double

char

Character

boolean

Boolean

        Integer num1 = new Integer(123); // 手动装箱方式，构造方法

Integer num2 = new Integer("123"); // 除Character类外的基本类型

Character num3 = new Character(‘a‘);

Integer num4 = Integer.valueOf(123);

Integer num5 = 1; // 自动装箱

int num1_1 = num1.intValue(); // 手动拆箱方式

int num5_1 = num5; // 自动拆箱

String sex=Character.toString(‘男‘);  // 基本类型->字符串

int num=Integer.parseInt("36"); // 字符串->基本类型  

//可用于校验字符是否合法

sex=‘男‘+"";  // 合并转换字符串的一种方式

    //获取随机数的两种random()方法：

    int show1 = (int) (Math.random() * 5.0D) + 1;

    int show2 = (int) (Math.random() * 10.0D) % 5 + 1;

System.out.println(Math.max(show1, show2));

    System.out.println(Math.abs(-10)); // 绝对值运算

System.out.println(Math.E + "\n" + Math.PI); // 两个常量

//Ps：random()返回一个大于等于0小于1的随机数。

    String s1 = "-Java-";

    String s1_1 = s1.toLowerCase(); // 转为小写

    String s1_2 = s1.toUpperCase(); // 转为大写

    String s2 = "渺千山暮雪，";

    String s3 = "万里层云，";

    String s4 = "只影向谁去？";

    String s5 = s2.concat(s3.concat(s4)); // 连接字符串

    String[] s6 = s5.split("。|，|？"); // 字符串拆分,用数组接收

    String s7 = s5.substring(1, 5); // 提取下标区间字段

    System.out.println(s1.equals(s1_2)); // 比较字符串，详见运算符章节

    System.out.println(s1_1.equalsIgnoreCase(s1_2));

    // 比较字符串，忽略大小写

    System.out.println(s5);

    for (String temp : s6) {

        System.out.println(temp);

    }

    System.out.println(s7); // indexOf()查询若不存在返回index = -1

    System.out.println(s7.length()); //字符串长度

    System.out.println("第一次出现逗号位置的下标：" + s5.indexOf("，"));

    System.out.println("最后出现逗号位置的下标：" + s5.lastIndexOf("，"));

    StringBuffer s1 = new StringBuffer("仰天大笑出门去");

    StringBuffer s2 = s1.append("无人知是荔枝来！");// 效率比concat()高

    StringBuffer s3 = s2.insert(7, "，");

    // 返回StringBuffer,不能用String接收。

    int s4 = s3.hashCode();

    //StringBuffer 好多方法可以用

    System.out.println(s3);

System.out.println(s4);

    Date date = new Date(); // 创建日期对象

    SimpleDateFormat formater // HH表示24时制

                 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    System.out.println("当前时间为：" + formater.format(date));

    Calendar t = Calendar.getInstance();

    // 抽象类，得到子类对象

    System.out.println("今天是" + t.get(Calendar.YEAR) + "年"

       + (t.get(Calendar.MONTH) + 1) + "月"

       + t.get(Calendar.DAY_OF_MONTH) + "日");

    // Calendar.DAY_OF_WEEK 中 Sunday是 1

    System.out.println("今天是星期"

        + (t.get(Calendar.DAY_OF_WEEK) - 1));

    }

    Random rand = new Random(47);

    int show1 = rand.nextInt(10); //产生一个大于等于0，小于10的随机数

    System.out.println(show1);

        //Math.random()方法底层是使用Random类实现的

    @SuppressWarnings("static-access")

    public static void main(String[] args) throws IOException {

    SimpleDateFormat formater

                    = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    File file1 = new File("I:/myDoc");

    // 创建新 File 实例,创建的是引用

    file1.mkdir();

    // 创建文件夹   file.mkdirs()

    file1.createTempFile("temp", ".txt", file1);

    // 创建临时文件

    System.out.println("是目录:" + file1.isDirectory());

    File file2 = new File("I:/myDoc/temp.txt");

    // 可是文件,也可是目录

    file2.createNewFile();

    //创建文件

    System.out.println("是文件:" + file2.isFile());

    System.out.println("文件是否存在:" + file2.exists());

    System.out.println("名称:" + file2.getName());

    System.out.println("相对路径: " + file2.getPath());

    System.out.println("绝对路径: " + file2.getAbsolutePath());

    System.out.println("文件大小:" + file2.length() + " 字节");

    System.out.println("最后修改日期: " +                                                       formater.format(file2.lastModified()));

}

System.out.println("文件是否删除:" + file2.delete());

//******** 问题：下列步骤数据存储和转换的过程是怎么样的？ 编码:UTF-8 *******

// 1. 把一个字符串 "苏A" 输入缓冲区 (33487)10000010 11001111 (65)01000001 UTF-16

// 1. 在缓冲区加高位转换成UTF=8 11101000/10001011/10001111/01000001

// 2. 转换成byte[] //用长度为4的字节数组接受 Byte1 = 11101000 Byte2 = ...

// 3 .然后存入文本 // 把四个字节数组存入文本（阅读文本时，解码器解码）

// 4. 然后从文本读取 //把文档内容以字节（符）型式读入内存，并转换成char

// 注：苏A == (\u82cf--16进制表达)

            ((232) 11101000 (139) 10001011 (143) 10001111) (65)01000001

// 如果不知道编码方式，可能同样的二进制数，解码方式有误，导致解码失败。

// IO操作的是序号，通过字库表，对应显示正确的字符。

public class Keep_Stream_Test {

    public static void main(String[] args) throws IOException {

    int date, temp;

    String line;

    String str = "苏A"; //UTF-8 汉字一个字符约三个字节

    char a = ‘C‘; // 一个整型代表一个字符，故可以互相转换

    byte[] words = str.getBytes(); // 把字符串内容写进字节数组

    System.out.println(System.getProperty("file.encoding"));

    // 获得本地平台的字符编码类型

    /**

     * 字节流写入数据

     * */

    FileOutputStream fos1 = new FileOutputStream("I:/text1.txt");

    fos1.write(552); // 读写的是序号 // 往里读，往外写 // 非正确演示

    fos1.write(words, 0, words.length);// 把字节数组存储的内容写进流

    /**

     * 字符流写入数据

     * */

    FileWriter fw = new FileWriter("I:/text1.txt", true);//不覆盖原文件

    BufferedWriter bw = new BufferedWriter(fw); // 装饰者模式

    bw.write("-南京");

    bw.write(‘)‘);

    bw.flush(); // 往外写时才用

    /**

     * 字节流读取数据

     * */

    FileInputStream fis1 = new FileInputStream("I:/text1.txt");

    BufferedInputStream bis1 = new BufferedInputStream(fis1);

    System.out.println("文件大小：" + bis1.available() + "字节\n");

    while ((date = fis1.read()) != -1) { // 把文本内容以字节型式读入内存

        System.out.print(date);

        System.out.print((char) date);

        System.out.println("\t" + Integer.toBinaryString(date));

    }

    // 此处对应关系与编码方式有关，多字节解码方式有误

    // 没有缓冲区，读一个字节，转一个。so如果汉字是单字节就不会出错鸟~

    System.out.println(‘\n‘);

    /**

     * 字符流读取数据

     * */

    FileReader fr1 = new FileReader("I:/text1.txt");

    BufferedReader br1 = new BufferedReader(fr1);

    while ((date = br1.read()) != -1) { // 把文档内容以字符型式读入内存

        System.out.print(date);

        System.out.print((char) date);

        System.out.println("\t" + Integer.toBinaryString(date));

    }

    while ((line = br1.readLine()) != null) {

        // 把文档内容以字符型式（每次一行）读入内存,返回字符串。这一段读不出流           只可用一次。

        System.out.print(line);

        // 由于字符流有缓冲区，所以2个字符读(Unicode)与一行行读都可以，最终按            编码方式处理。

    }

    /**

     * 字符流读取数据 InputStreamReader 是字节流通向字符流的桥梁

     * */

    InputStreamReader isr = new InputStreamReader(fis1, "UTF-8");

    // 转换流

    BufferedReader br2 = new BufferedReader(isr);// 缓冲流

    while ((temp = br2.read()) != -1) {

        System.out.print((char) temp); // 流使用一次就不能再用了？？

    }

    System.out.println(‘\u82cf‘);// 十六进制表示一个字符

    System.out.println((byte) a);

    }

}

    /**

     * 二进制文件读取操作

     * */

    FileInputStream fis3 = new FileInputStream("I:/text1.txt");

    DataInputStream dis1 = new DataInputStream(fis3);

    /**

     * 二进制文件写入操作

     * */

    FileOutputStream fos2 = new FileOutputStream("I:/text2.txt");

    DataOutputStream dos1 = new DataOutputStream(fos2);

    int temp2;

    while ((temp2 = dis1.read()) != -1) { // 读取文件并写入文件

        dos1.write(temp2);

    }

    dos1.writeUTF("Hello"); // 将一个字符串写入文件

    dos1.flush();

       /**

      * System.out 重定向向文件输出

       * */

       PrintStream ps = new PrintStream(new FileOutputStream("work"));

       System.setOut(ps);

       System.out.println("Hello World!");

       /**

        * System.in 重定向从文件输入

        * */

       FileInputStream fis = new FileInputStream("work");

       System.setIn(fis);

       Scanner sc = new Scanner(System.in);

       while (sc.hasNextLine()) {

           System.out.println(sc.nextLine());

       }

    ObjectOutputStream oos = new ObjectOutputStream(new                                             FileOutputStream("c:\\myDoc\\stu.txt"));

    Student stu = new Student("安娜", 30, "女");

    // 对象序列化

    oos.writeObject(stu);

    ObjectInputStream ois = new ObjectInputStream(new FileInputStream(

                                                   "c:\\myDoc\\stu.txt"));

    // 对象反序列化

    Student stu1 = (Student) ois.readObject();

    System.out.println("姓名为：" + stu1.getName());

    System.out.println("年龄为：" + stu1.getAge());

    System.out.println("性别为：" + stu1.getGender());

Ps:class Student implements java.io.Serializable

苏A 的 存 储 形 式 为 ：

ASCII 码： (33487) 10000010 11001111      (65) 01000001

UTF-8： (\u82cf)( (232) 11101000 (139) 10001011      (143) 10001111)      (65) 01000001

5678 的 存 储 形 式 为 ：

ASCII 码： 00110101   00110110   00110111   00111000 （四个字节）

二进制：   00010110   00101110 （两个字节）

public class Thread_Demo {

    public static void main(String[] args) {

    Demo1 d1 = new Demo1(); // Runnable实现类,只有run()方法

    Thread t = new Thread(d1); // Thread对象调用start()方法

    t.start();

    Demo2 d2 = new Demo2();

    d2.start(); //Thread对象调用start()方法

    }

}

class Demo1 implements Runnable { // 实现Runnable接口方式实现多线程

    public void run() {

    System.out.println("Runnable");

    }

}

class Demo2 extends Thread { // 继承Thread类实现多线程

    public void run() {

    System.out.println("Thread");

    }

同步代码块：

public class ThreadDemo {

    public static void main(String[] args) {

    Ticket t = new Ticket();

    Thread t1 = new Thread(t, "窗口一");

    Thread t2 = new Thread(t, "窗口二");

    Thread t3 = new Thread(t, "窗口三");

    Thread t4 = new Thread(t, "窗口四");

    t1.start();

    t2.start();

    t3.start();

    t4.start();

    }

}

class Ticket implements Runnable {

    private int ticket = 100;

    public void run() {

    while (true) {

        synchronized (new Object()) {

// synchronized关键字，用来修饰方法或代码块的时，保证同时最多只有一个线程执行    该段代码。

        if (ticket <= 0)

            break;

        System.out.println(Thread.currentThread().getName()

            + "---卖出"+ ticket--);

        }

    }

    }

}

同步函数：

public class ThreadDemo {

    public static void main(String[] args) {

    Ticket t = new Ticket();

    Thread t1 = new Thread(t, "窗口一");

    Thread t2 = new Thread(t, "窗口二");

    Thread t3 = new Thread(t, "窗口三");

    Thread t4 = new Thread(t, "窗口四");

    t1.start();

    t2.start();

    t3.start();

    t4.start();

    }

}

class Ticket implements Runnable {

    private int ticket = 100;

public synchronized void saleTicket() {

    if (ticket > 0)

        System.out.println(Thread.currentThread().getName() + "卖出了"

            + ticket--);

    }

    public void run() {

    while (true) {

        saleTicket();

    }

    }

}

等待唤醒机制：

生产消费机制：

       // 使用域名创建对象

        InetAddress inet1 = InetAddress.getByName("www.163.com");

        System.out.println(inet1);

        // 使用IP创建对象

        InetAddress inet2 = InetAddress.getByName("127.0.0.1");

        // 127.0.0.1是一个回送地址,指本地机,一般用来测试使用

        System.out.println(inet2);

        // 获得本机地址对象

        InetAddress inet3 = InetAddress.getLocalHost();

        System.out.println(inet3);

        // 获得对象中存储的域名

        String host = inet3.getHostName();

        System.out.println("域名：" + host);

        // 获得对象中存储的IP

        String ip = inet3.getHostAddress();

        System.out.println("IP:" + ip);

        // 创建一个URL的实例

        URL baidu = new URL("http://www.baidu.com");

        URL url = new URL(baidu, "/index.html?username=tom#test");

        // ？表示参数，#表示锚点

        System.out.println(url.getProtocol());

        // 获取协议

        System.out.println(url.getHost());

        // 获取主机

        System.out.println(url.getPort());

        // 如果没有指定端口号，根据协议不同使用默认端口。getPort()方法的返回值为 -1

        System.out.println(url.getPath());

        // 获取文件路径

        System.out.println(url.getFile());

        // 文件名，包括文件路径+参数

        System.out.println(url.getRef());

        // 相对路径，就是锚点，即#号后面的内容

        System.out.println(url.getQuery());

        // 查询字符串，即参数

       URL url_2 = new URL("http://www.baidu.com");

        InputStream is = (InputStream) url_2.openStream();

        // 通过openStream方法获取资源的字节输入流

        InputStreamReader isr = new InputStreamReader(is, "UTF-8");

        // 将字节输入流转换为字符输入流,如果不指定编码，中文可能会出现乱码

        BufferedReader br = new BufferedReader(isr);

        // 为字符输入流添加缓冲，提高读取效率

        String data = br.readLine();// 读取数据

        while (data != null) {

        System.out.println(data);// 输出数据

        data = br.readLine();

        }

        br.close();

        isr.close();

        is.close();

public class DemoTCP_Server {

    public static void main(String[] args) throws IOException {

    /**

     * 基于TCP协议的Socket通信，实现用户登录，服务端

     */

    // 1、创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并监听此端口

    ServerSocket serverSocket = new ServerSocket(10086);

    // 2、调用accept()方法开始监听，等待客户端的连接

    Socket socket = serverSocket.accept();

    // 3、getInputStream()方法获取输入流，并读取客户端信息

    InputStream is = socket.getInputStream(); // 返回InputStream

    InputStreamReader isr = new InputStreamReader(is); // 转化流处理

    BufferedReader br = new BufferedReader(isr);

    String info = null;

    while ((info = br.readLine()) != null) {

        System.out.println("我是服务器，客户端说：" + info);

    }

    socket.shutdownInput(); // 关闭输入流

    // 4、获取输出流，响应客户端的请求

    OutputStream os = socket.getOutputStream();

    PrintWriter pw = new PrintWriter(os);

    pw.write("欢迎您！");

    pw.flush();

    // 5、关闭资源，注意顺序

    pw.close();

    os.close();

    br.close();

    isr.close();

    is.close();

    socket.close();

    serverSocket.close();

    }

}

public class DemoTCP_Clinet { // 客户端

    public static void main(String[] args) throws IOException {

    // 1、创建客户端Socket，指定服务器地址和端口

    Socket socket = new Socket("localhost", 10086);

    // 2、获取输出流，向服务器端发送信息

    OutputStream os = socket.getOutputStream();// 字节输出流

    PrintWriter pw = new PrintWriter(os);// 将输出流包装成打印流

    pw.write("用户名：admin；密码：123");

    pw.flush();

    socket.shutdownOutput();

    // 关闭客户端的输出流。相当于给流中加入一个结束标记-1

    // 3、获取输入流，并接收服务器端的反馈信息

    InputStream is = socket.getInputStream();

    // BufferedReader br = new BufferedReader(new InputStreamReader(is));

    Scanner input = new Scanner(new InputStreamReader(is));

    while (input.hasNextLine()) { //用Scanner接收输入流,对比服务端方法优劣

        System.out.println("我是客户端，服务器说：" + input.nextLine());

    }

    // 4、关闭资源

    input.close();

    is.close();

    pw.close();

    os.close();

    socket.close();

    }

}

public class DemoThread_Clinet { // 客户端

    public static void main(String[] args) throws IOException {

    Socket socket = new Socket("localhost",10086);

    socket.close();

    }

}

public class DemoThread_Server extends Thread {// 服务器端

    Socket socket = null;

    public DemoThread_Server(Socket socket) { // 以Sockeet为参的构造方法

    this.socket = socket;

    }

    public void run() {

    }

    public static void main(String[] args) throws IOException {

    ServerSocket serverSocket = new ServerSocket(10086);

    Socket socket = null;

    int count = 0;// 记录客户端的数量

    while (true) {

        socket = serverSocket.accept();

        // 阻塞状态，接收客户端请求，然后往下执行，新增线程

        DemoThread_Server serverThread = new DemoThread_Server(socket);

        serverThread.start();

        count++;

        System.out.println("客户端连接的数量：" + count);

    }

    }

}

public class DemoUDP_Server {

    /**

     * 服务器端，实现基于UDP的用户登录

     * */

    public static void main(String[] args) throws IOException {

    // 1、创建服务器端DatagramSocket，指定端口

    DatagramSocket socket = new DatagramSocket(8888);

    // 2、创建数据报，用于接受客户端发送的数据

    byte[] data = new byte[1024];

    DatagramPacket packet = new DatagramPacket(data, data.length);

    // 3、接受客户端发送的数据

    socket.receive(packet);// 此方法在接受数据报之前会一直阻塞

    // 4、读取数据

    String info = new String(data, 0, data.length);

    System.out.println("我是服务器，客户端告诉我" + info);

    // 1、定义客户端的地址、端口号、数据

    InetAddress address = packet.getAddress();

    int port = packet.getPort();

    byte[] data2 = "欢迎您！".getBytes();

    // 2、创建数据包，包含响应的数据信息

    DatagramPacket packet2 = new DatagramPacket(data2, data2.length,

        address, port);

    // 3、响应客户端`

    socket.send(packet2);

    // 4、关闭资源

    socket.close();

    }

}

public class DemoUDP_Clinet { // 客户端

    public static void main(String[] args) throws IOException {

    // 1、定义服务器的地址、端口号、数据

    InetAddress address = InetAddress.getByName("localhost");

    int port = 8888;

    byte[] data = "用户名：admin;密码：123".getBytes();

    // 2、封包，包含发送的数据信息

    DatagramPacket packet = new DatagramPacket(data, data.length, address,

        port);

    // 3、创建DatagramSocket对象

    DatagramSocket socket = new DatagramSocket();

    // 4、向服务器发包

    socket.send(packet);

    // 1、创建数据包，用于接受服务器端响应数据

    byte[] data2 = new byte[1024];

    DatagramPacket packet2 = new DatagramPacket(data2, data2.length);

    // 2、接受服务器响应的数据

    socket.receive(packet2);

    String reply = new String(data2, 0, packet2.getLength());

    System.out.println("我是客户端，服务器说：" + reply);

    // 4、关闭资源

    socket.close();

    }

}

<?xml version = "1.0" encoding="UTF-8"?>

<PhoneInfo>

    <Brand name="华为">

       <Type name="U8650"></Type>

       <Type name="HW123"></Type>

       <Type name="HW321"></Type>

    </Brand>

    <Brand name="苹果">

       <Type name="Iphone5"></Type>

       <Type name="Iphone6"></Type>

       <Type name="Iphone6s"></Type>

    </Brand>

</PhoneInfo>

public class ParseXMLDemo { // Document、NoteList、Note、Element 接口

    private Document document;

    public static void main(String[] args) throws Exception {

    ParseXMLDemo pd = new ParseXMLDemo();

    pd.getDocument();

    pd.showInfo();

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

    pd.add();

    pd.delete();

    pd.update();

    pd.showInfo();

    pd.saveXML("E:/JAVA/U1/U2-1/src/chapter06/new.xml");

    }

    public void getDocument() throws Exception { // 获得DOM树

    DocumentBuilderFactory factory =                                                       DocumentBuilderFactory.newInstance();

    DocumentBuilder builder = factory.newDocumentBuilder();

    document =                                                                    builder.parse("E:/JAVA/U1/U2-1/src/chapter06/XMLDemo.xml");

    // 1、创建解析器工厂 2、创建解析器 3、操作xml对象

    }

    public void showInfo() {// 获取手机品牌和属性

    NodeList brands = document.getElementsByTagName("Brand");

    for (int i = 0; i < brands.getLength(); i++) {

        Node node = brands.item(i);

        Element eleBrand = (Element) node;// 节点强转元素

        System.out.println(eleBrand.getAttribute("name"));

        NodeList types = node.getChildNodes();

        for (int j = 1; j < types.getLength(); j++) {

       Node typeNode = types.item(j);

       if (typeNode.getNodeType() == node.ELEMENT_NODE) {//元素节点

           Element eleType = (Element) typeNode;

           System.out.println("\t" + eleType.getAttribute("name"));

       }

        }

    }

    }

    public void saveXML(String path) throws Exception {

    TransformerFactory factory = TransformerFactory.newInstance();

    factory.setAttribute("indent-number", "4");// 设置缩进

    Transformer transformer = factory.newTransformer();

    transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");//转换器

    transformer.setOutputProperty(OutputKeys.INDENT, "yes");//开启缩进

    // StreamResult result=new StreamResult(new FileOutputStream(path));

    DOMSource source = new DOMSource(document);// 设置源

    StreamResult result = new StreamResult(new OutputStreamWriter(

       new FileOutputStream(path), "UTF-8"));// 设置目标

    transformer.transform(source, result);// 转换

    }

    public void add() throws Exception {// 添加

    Element element1 = document.createElement("Brand");

    element1.setAttribute("name", "三星");

    Element element2 = document.createElement("Type");

    element2.setAttribute("name", "Note3");

    element1.appendChild(element2);

    document.getElementsByTagName("PhoneInfo").item(0)

       .appendChild(element1);

    this.saveXML("E:/JAVA/U1/U2-1/src/chapter06/new.xml");

    }

    public void update() throws Exception {// 修改

    NodeList brands = document.getElementsByTagName("Brand");

    for (int i = 0; i < brands.getLength(); i++) {

        Node brand = brands.item(i);

        Element eleBrand = (Element) brand; // 修改的是元素的属性

        eleBrand.setAttribute("id", i + ""); // i转为String

        this.saveXML("E:/JAVA/U1/U2-1/src/chapter06/new.xml");

    }

    }

    public void delete() throws Exception {// 删除

    NodeList brands = document.getElementsByTagName("Brand");

    for (int i = 0; i < brands.getLength(); i++) {

        Node brand = brands.item(i);

        Element eleBrand = (Element) brand;

        if ("华为".equals(eleBrand.getAttribute("name"))) {

       eleBrand.getParentNode().removeChild(eleBrand);

        }

        this.saveXML("E:/JAVA/U1/U2-1/src/chapter06/new.xml");

    }

    }

}