java 基础知识

1.Scanner用法
Scanner sc = new Scanner(System.in); //创建键盘录入 System.out.println("请输入一个整数"); //将键盘录入的数据存储到x中 int x = sc.nextInt(); System.out.println(x);

练习:输入两个值,并将最大值输出

Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个整数");
int x = sc.nextInt();
System.out.print("请输入第二个整数");
int y = sc.nextInt();
int temp = (x>y) ? x:y;
System.out.println(temp);

2.进制

  1 byte = 8bit

  1 k = 1024b(m、g、t以此类推) 

  二进制:0和1组成,     以0b开头

  八进制:有0-7组成,     以0开头

  十六进制:有0-9,a-f组成, 以0x开头

  原码

    二进制定点表示法,最高位位符号位,“0”表示正,“1”表示负,其余为数值的大小

    00000111 (+7)

    10000111 (-7)

    11111000 (-7反码)

    11111001 (-7补码)

  反码:正数的反码与其原码相同,负数的反码是对其原码诸位取反,符号位除外

  补码:正数的补码与其原码相同,负数的补码是对其反码的末位加1

3.数据类型

  基本数据类型

   整数型:

    byte  1个字节 -128-127

    short  2个字节

    int   4个字节

    long   8个字节

   浮点型:

    float  4个字节

    double  8个字节

   字符型:

    char   2个字节

   布尔型:

     boolean 理论上1/8字节,java没有明确定义大小

   变量与常量区别:

   byte b1 = 3;

   byte b2 = 4;

   //1.数值默认都是int byte和byte(或short,char)进行运算时都会提升为int,两个int相加结果为int类型

   //2.b1和b2是两个变量,变量存储的值是变化的,在编译的时候无法判断里面具体的值,相加会超过byte取值范围

   byte b3 = b1+b2; //编译出错

   //java编译器有常量优化机制,编译时知道值,判断3+4没超过byte值

   byte b4 = 3+4; //正确

引用数据类型

  

3.流程控制

  顺序结构

  选择结构

  if

  int x = 10;

  switch(表达式){

    case 值1:

      语句体1;

      break;

    ....

    default;

      语句体n;

      break;

  }

  for(){

  }

   while(){

  }

  do{

    循环体语句;

    控制条件语句;

   }while(判断条件语句);

  三者的不同:

    do...while:循环至少执行一次循环体

    for循环:变量会及早的从内存中释放

    while循环:变量不会释放

 4.控制跳转语句标号

a:for(int i=1;i<= 10;i++){  //a就是标号,只要是合法的标识符即可
    System.out.println("i="+i);
    b:for(int j=1;j<=10;j++){
        System.out.println("j="+j);
        break a; //结束a循环,直接break就只结束b循环 
    }            
}
break用于switch和循环(结束整个循环)

 continue用于循环(结束本次循环,进行下次循环)

    return (结束方法)

5.方法

  格式:修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数2...){

      方法体语句;

      return 返回值;

   }

  方法重载:方法名相同,参数列表不同,与返回值类型无关

  重载的分类:

    1.参数个数不同

    2.参数类型不同 

    3.参数顺序不同

public static void main(String[] args) {
    double sum1 = add(10,37);
    int sum2 = add(12,34,56);
    double sum3 = add(12.4,45.3);
    System.out.println(sum1);
    System.out.println(sum2);
    System.out.println(sum3);
}
    
public static double add(int a ,int b){
    return a+b;
}
    
public static int add(int a,int b,int c){
    return a+b+c;
}
public static double add(double a,double b){
    return a+b;
}

6.数组

  数据类型[ ] 数组名 = new 数据类型[数组的长度] ;

  默认初始化值:

    整数类型:byte、 short 、int 、long 默认是0

    float、double 默认是0.0

    布尔型:boolean 默认是false

         字符:char 默认‘\u0000’ (char在内存占两个字节,16个二进制,

                每个0代表是16进制的0,16进制1位代表4个二进制位,‘\u0000’总共16个二进制) 

  静态初始化格式:数据类型[ ] 数组名 = new 数据类型[ ]{ 元素1,元素2....} 

          数据类型[ ] 数据名 = {元素1,元素2...}

    public static void main(String[] args) {
        int[] arr = {11,33,55,22,66};
        int max = getMax(arr);
        System.out.println(max);
        reverseArraly(arr);
        print(arr);
        
    }
    //获取数组最大值
    public static int getMax(int[] arr){
        int max = arr[0];
        for(int i=1;i<arr.length;i++){
            if(max < arr[i]){
                max = arr[i];
            }
        }
        return max;
    }
    //数组元素反转
    public static void reverseArraly(int[] arr){
        for(int i=0;i<arr.length/2;i++){
            int temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }
    }
    //遍历数组
    public static void print(int[] arr){
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]);
        }
    } 

7.内存分配

    栈:存储局部变量

    堆:存储new出来的数组或对象

    方法区

    本地方法区:和系统有关

    寄存器:给cpu使用

. 一个数组的内存图

8.面向对象

  面向对象特征:

    封装

    继承

    多态  

 

 9.成员变量和局部变量

   成员变量:堆内存、随着对象创建而存在,随着对象消失而消失、有默认初始化值

   局部变量:栈内存、随着方法调用而存在,随着方法的调用完毕而消失、没有默认初始化值,必须定义

10.封装

   原则:把属性隐藏,提供公共方法对其访问

   private :被修饰的成员只能在本类中使用

   this :表示当前类的对象引用(当前类的一个对象)  

11.构造方法

   方法名与类名相同,没有返回值(包括void)-----给对象数据进行初始化  

   注意:没有给出构造方法,系统将自动提供一个无参构造方法

      给出了构造方法,系统将不再提供默认的无参构造方法,如果我们还想使用无参构造方法,就必须自己给出

   构造方法重载:

     给成员变量赋值两种方法:setXXX()    构造方法

public class StudentMethod {
    private String name;
    private int age;
    
    public StudentMethod(){
        System.out.println("这是无参构造方法");
    }
    public StudentMethod(String name){
        System.out.println("这是个带一个String类型的构造方法");
        this.name = name;
    }
    public StudentMethod(String name, int age){
        System.out.println("这是个带多个参数的构造方法");
        this.name = name;
        this.age = age;
    }
    
    public void show(){
        System.out.println(name+"----"+age);
    }
}

public class StudentMethodTest {
    public static void main(String[] argus){
        StudentMethod sm = new StudentMethod();
        sm.show();   //结果:    这是无参构造方法   null----0
        
        StudentMethod sm1 = new StudentMethod("张三");
        sm1.show();  //结果: 这是个带一个String类型的构造方法    张三----0
        
        StudentMethod sm2 = new StudentMethod("李四",12);
        sm2.show();    //结果:这是个带多个参数的构造方法        李四----12
    }
}

 12.static

  多个对象相同的成员变量(被所有对象共享)

  可以通过类名调用,本身也可以通过对象调用

    

  注意事项:

    1. 在静态方法中是没有this关键字的(静态是随着类的加载而加载,

      this是随着对象的创建而存在,静态比对象先存在)

    2. 静态方法只能访问静态的成员变量和静态的成员方法

       静态方法:

          成员变量:只能访问静态变量

          成员方法:只能访问静态成员方法

      非静态方法:

          成员变量:可以是静态变量,也可以是非静态变量

          成员方法:可以是静态的成员方法,也可以是非静态的成员方法

13. 继承

   注意事项:

    a:子类只能继承父类所有非私有的成员(成员方法和成员变量)

    b:子类不能继承父类的构造方法,可以通过super关键字去访问父类构造方法

       c:不要为了部分功能而去继承

   继承具有就近原则,子类有就不用父类的

  this和super的区别:

    this:当前对象的引用

    super:当前对象父类的引用

    成员变量:

       this:调用本类的成员变量,也可以调用父类的成员变量

       super:调用父类的成员变量

 

public class Father {
    int num1 = 10;
    int num2 = 30;
    
    private String name;
    private int age;
    
    public Father(){
        System.out.println("Father 空参构造");
    }
    
    public Father(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("Father 有参构造");
    }
    
    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 class Son extends Father {
    int num2 = 20;
    
    public void print(){
        System.out.println(this.num1); //10 this既可以调用本类的,也可以调用父类的(本类没有的情况下)
        System.out.println(this.num2); //20  就近原则,子类有就不用父类的
        System.out.println(super.num2); //30 super调用父类 
    }
    
    public Son(){
        //此处隐藏    super()  将父类的无参构造方法注释 将报错
        System.out.println("son 空参构造");
    }
    
    public Son(String name,int age){
        //此处隐藏    super() 将父类的无参构造方法注释 将报错
        super(name,age); //调用父类有参构造方法
        System.out.println("Son 有参构造");
    }
}

public static void main(String[] args) {
        Son s = new Son();
        s.print();
        
        Son s1 = new Son();  //输出 :Father空参构造      son空参构造
        System.out.println("-------");
        Son s2 = new Son("张三",33); //Father空参构造    Son有参构造
        System.out.println(s2.getName()+"...."+s2.getAge()); //张三....33
        
    }

 重写:当子类需要父类的功能,而功能主体子类有自己特有内容,可以重写父类方法

   注意事项:

    a. 父类中私有方法不能被重写

    b.子类重写父类方法是,访问权限不能更低

    c.父类静态方法,子类也必须通过静态方法重写

final:

  修饰类:类不能被继承

  修饰变量:变量变成常量,只能被赋值一次

  修饰方法:方法不能被重写

14.多态

  事物存在的多种形态

  多态前提:要有继承关系、要有方法重写、要有父类引用指向子类对象

  1.多态中成员访问特点之成员变量

  2.多态中的成员访问特点之成员方法 

  3.多态中的成员访问特点之静态成员方法  

public class Father {
    int num=10;
    
    public void print(){
        System.out.println("father");
    }
    
    public static void method(){
        System.out.println("father static method");
    }
}

public class Son extends Father{
    int num = 20;
    
    public void print(){
        System.out.println("son");
    }
    
    public static void method(){
        System.out.println("son static method");
    }
}

public class Test1 {

    public static void main(String[] args) {
        //多态中成员访问特点之成员变量
        Father f = new Son(); //父类引用指向子类对象
        System.out.println(f.num);  //结果:10 输出的是父类的成员变量 (编译看左边,运行看左边)
        Son s = new Son();
        System.out.println(s.num);  //结果:20 调自己成员变量 (编译看左边,运行看左边)
        
        //多态中的成员访问特点之成员方法
        Father f1 = new Son();
        f1.print();   //结果:son (编译看左边,运行看右边)
        
        //多态中的成员访问特点之静态成员方法
        Father f2 = new Son();
        f2.method(); //结果:father static method(相当于是Father.method 编译看左边,运行看左边)
    }

}

   4.多态中向上转型和向下转型

  

多态

  instanseof :判断前边的引用是否是后边的数据类型

抽象类(abstract):

          抽象类和抽象方法必须用abstract关键字修饰:

            abstract class 类名{ }

            public abstract void eat();

          抽象不一定有抽象方法,有抽象方法的类一定是抽象类或者是接口

          抽象类不能被实例化

          抽象类的子类要么是抽象类,要么重写抽象类中的所有抽象方法

抽象类成员特点:

  a:成员变量:既可以是变量,也可以是常量(abstract不可以修饰成员变量)

  b:构造方法:有

      用于子类访问父类的初始化

  c:成员方法:既可以是抽象的,也可以是非抽象的

 一个抽象类没有抽象方法,是可以定义为抽象类(意义:定义为抽象不让该类被实例化)

abstract和static不能共存:abstract修饰的方法没有方法体,被static修饰的可以用类名.调用,但是类名.调用没有意义的

abstract和final不能共存:被abstract修饰的方法强制子类重写,被final修饰的不让子类重写

abstract和private不能共存:同理final

15.接口

  对外提供规则的都是接口

  interface 接口名{}

  类实现接口implements 表示:class 类名 implements 接口名{ }

  接口不能实例化

  接口的子类:可以是抽象类,但意义不大,可以是具体类,要重写接口中所有抽象方法

public interface Inter {
    public abstract void print(); //接口中的方法都是抽象的
}

public class Demo implements Inter{
    @Override
    public void print() {
        // TODO Auto-generated method stub
    }

}

public class DemoTest {
    public static void main(String[] args) {
        //Inter i = new Inter(); //接口不能被实例化,因为调用抽象方法没有意义
        Inter i = new Demo(); //父类引用指向子类对象
        i.print();
    }
}

成员变量:只能是常量,并且是静态的并公共的

     默认修饰符:public static final

构造方法:没有

成员方法:只能是抽象方法

     默认修饰符:public abstract

public interface Inter {
    int num =10; //默认下面的
    //public static final int num = 10; //一般写法
    public void print();
}

public class Demo implements Inter{
    @Override
    public void print() {
        //num = 20; //错误,接口定义的成员变量是常量
        System.out.println(num);
    }

}

public class DemoTest {

    public static void main(String[] args) {
        Demo d = new Demo();
        d.print(); //输出10
        System.out.println(Inter.num);
    }
}

 设计理念区别:

  抽象类:抽象类中定义的是该继承体系的共性功能

  接口:    接口中定义的是该继承体系的扩展功能

  

//测试类
public class Test {
    /**
     * 动物类:姓名,年龄,吃饭,睡觉
     * 猫和狗
     * 动物培训接口:跳高
     */
    public static void main(String[] args) {
        Cat cat = new Cat("加菲",8);
        cat.eat(); //猫吃鱼
        cat.sleep(); //猫睡觉
        JumpCat jc = new JumpCat();
        jc.eat(); //猫吃鱼
        jc.sleep(); //猫睡觉
        jc.jump(); //猫跳高

    }
}

//动物类
public abstract class Animal {
    private String name;
    private int age;
    //空参构造
    public Animal(){
        
    }
    //有参构造
    public Animal(String name,int age){
        this.name = name;
        this.age = age;
    }
    public abstract void eat(); //吃饭
    
    public abstract void sleep();//睡觉
    
    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 interface Jump {
    public void jump();
}

//猫类
public class Cat extends Animal{
    //空参构造
    public Cat(){
        
    }
    //有参构造
    public Cat(String name,int age){
        super(name,age);
    }
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void sleep() {
        System.out.println("猫睡觉");
    }
    
}

//跳高猫类
public class JumpCat extends Cat implements Jump{

    @Override
    public void jump() {
        System.out.println("猫跳高");
    }
    
}

 16.四种权限修饰符

        本类   同一个包下(子类和无子类)   不同包下(子类)   不同包下(无关类)

  private    Y    

  默认     Y    Y

  protected   Y    Y            Y

  public      Y    Y            Y        Y

17.String、StringBuffer、StringBuild

  String 

    字符串面值“abc”看成是一个字符串对象

    字符串是一个常量,一旦被赋值,不能被改变

       不可变得字符序列

  StringBuffer  

    线程安全的可变字符序列,效率低

  StringBuild

    线程不安全的可变字符序列,效率高

String类虽然是引用数据类型,但是当作参数传递时和基本类型是一样的(不改变其值)

StringBuffer 作为参数传递,改变值

/**
  * 数组高级冒泡排序:
  * 相邻元素两两比较,大的往后放,第一次完毕,最大值出现在了最大索引处

  * 第一次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3],arr[3]与arr[4]比较4次
  * 第二次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3]比较3次
  * 第三次:arr[0]与arr[1],arr[1]与arr[2]比较2次
  * 第四次:arr[0]与arr[1]比较1次

*/
public class StringDemo {
    public static void main(String[] args){
        int[] arr ={24,69,80,57,13};
        maopao(arr);
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }            
    }
    
    public static void maopao(int[] arr){
        for(int i=0;i<arr.length -1;i++){
            for(int j=0;j<arr.length-1-i ;j++){ // -i为了提高效率
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }

        }
    }    
}

 

/**
     * 选择排序:
     * 用一个索引位置上的元素,依次与其他索引位置上的元素比较,小在前面大的在后面
     * 第一次:arr[0]分别与arr[1-4]比较,比较4次
     * 第二次:arr[1]分别与arr[2-4]比较,比较3次
     * 第三次:arr[2]分别与arr[3-4]比较,比较2次
     * 第四次:arr[3]与arr[4]比较,比较1次
     */
    public static void main(String[] args) {
        int[] arr = {24,69,80,57,13};
        xuanze(arr);
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
        
    }
    public static void xuanze(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=1+i;j<arr.length;j++){
                if(arr[i] > arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;            
                }
            }
        }
    }

 

/**
     * 二分查找;(前提元素有序)
     * 
     */
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55,66};
        System.out.println(getIndex(arr,44));
    }
    
    public static int getIndex(int[] arr ,int value){
        int min =0;
        int max = arr.length-1;
        int mid = (min + max)/2;        
        while(arr[mid] != value){ //当中间值不等于要找的值,就开始循环查找
            if(arr[mid] < value){//当中间值小于要找的值
                min = mid +1;    //最小的索引改变
                
            }else if(arr[mid] > value){//当中间值大于要找的值
                max = mid -1;    //最大的索引改变
            }
            mid =(min + max)/2; //无论最大最小改变,中间索引都会随之改变
            if(min > max){
                return -1;
            }
        }                        
        return mid;
    }

 18.Arrays类

public static void main(String[] args) {
        int[] arr ={33,22,11,44,66,55};
        System.out.println(Arrays.toString(arr));//数组转字符串
        
        Arrays.sort(arr); //排序数组
        System.out.println(Arrays.toString(arr));
        
        int[] arr2 = {11,22,33,44,55,66};
        System.out.println(Arrays.binarySearch(arr2, 44)); //查找元素位置(二分查找法)

    }    

  

17.集合

 

//collection集合 一些方法
        Collection c = new ArrayList(); //父类引用子类对象
        c.add("ssss");    
        c.add(true);                    //自动装箱new Boolean(true)
        c.add(100);
        c.add(new Student());
        System.out.println(c);  //[ssss, true, 100, collection.Student@42d73fb7]
        c.remove("ssss");
        System.out.println(c);//[true, 100, collection.Student@6cd737e3]
        boolean b =c.contains(100);
        System.out.println(b); //true 是否包含
        System.out.println(c.size()); //获取元素个数
        c.clear();
        System.out.println(c);//[]
        System.out.println(c.isEmpty()); //true 是否为空
        
        //collection集合转数组
        Collection c1 = new ArrayList(); //父类引用子类对象
        c1.add("2");
        c1.add("1");
        Object[] arr = c1.toArray();
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
        //collection集合带All的方法
        Collection c2 = new ArrayList(); //父类引用子类对象
        c2.add("aa");
        c2.add("bb");
        Collection c3= new ArrayList(); //父类引用子类对象
        c3.add("aa");
        c3.add("cc");
        c3.add("dd");
        c2.addAll(c3);
        System.out.println(c2);//[aa, bb, aa, cc, dd]
        c2.removeAll(c3);
        System.out.println(c2);//[bb] //删除的是交集
        System.out.println(c2.containsAll(c3)); //false判断是否包含
        c2.retainAll(c3);
        System.out.println(c2); //取交集
        //迭代
        Collection c4= new ArrayList(); //父类引用子类对象
        c4.add("aa");
        c4.add("cc");
        c4.add("dd");
        Iterator it = c4.iterator(); //获取迭代器
        /*boolean b1 = it.hasNext(); //判断集合是否有元素
        Object obj = it.next();*/
        while(it.hasNext()){
            System.out.println(it.next());
        }

 18.集合框架(数据结构之数组和链表) 

 

  数组:查询和修改快

        增删慢

  链表:查询和修改慢

      增删快

List三个子类特点:

  ArrayList:底层数据结构是数组,查询快,增删慢

       线程不安全,效率高

  Vector(向量):底层数据结构是数组,查询快,增删慢

      线程安全,效率低

  LinkedList:底层结构是链表,查询慢,增删快

      线程不安全,效率高

/**
     * 数组转集合
     */
    public static void main(String[] args) {
        String[] arr = {"a","b","c"};
        List<String> list = Arrays.asList(arr); 
        //list.add("d"); 不能增加
        System.out.print(list);
    }
/**
     * 集合转数组
     */
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        String[] arr = list.toArray(new String[0]); //当集合转换数组时,数组的长度如果是小于等于集合的size
                                                //转换后的数组长度等于size,如果大于集合size,分配的数组的长度就是指定的长度
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }

 19.set

  HashSet:无索引、不可以重复、存取不一致

  LinkedHashSet:可以保证怎么存怎么取,其他属性同HashSet

  TreeSet:可以排序(自然排序),其他同HashSet

20.Map

  HashMap和Hashtable

  共同点:底层都是哈希算法,都是双列集合

  不同点:1.HashMap是线程不安全的,效率高

         Hashtable是线程安全的,效率低

      2.HashMap可以存储nul键和null值

       Hashtable不能存储nul键和null值

 21.File

/**
     * File(String pathname):根据一个路径得到File对象
     * File(String parent,String child):根据一个目录和一个子文件/目录得到File对象
     * File(File parent,String child):根据一个父File对象和一个子文件/目录得到File对象
     */
    public static void main(String[] args) {
        File file = new File("C:\\Notepad++\\localization\\chineseSimplified.xml");
        System.out.println(file.exists());
        
        String parent = "C:\\Notepad++\\localization";
        String child = "chineseSimplified.xml";
        File file1 = new File(parent,child);
        System.out.println(file1.exists());

        File parentFile = new File("C:\\Notepad++\\localization");
        String child1 = "chineseSimplified.xml";
        File file2 = new File(parentFile,child1);
        System.out.println(file2.exists());
    }
/**
     * 创建功能
     *     Public boolean createNewFile():创建文件 如果存在这样的文件,就不创建了
     *     public boolean mkdir():创建文件夹 如果存在这样的文件夹,就不创建了
     *     public boolean mkdirs():创建文件夹,如果父文件夹不存在,会帮你创建出来
     * 案列演示:
     *     File类的创建功能
     *     注意事项:如果创建文件或文件夹忘写盘路径,那么默认在项目路径下 
     */
    public static void main(String[] args) throws IOException {
        File file = new File("xxx.txt"); //默认创建在项目下
        file.createNewFile();
        
        File file2 = new File("aaa");
        System.out.println(file2.mkdir());
        
        File file3 = new File("ccc\\ddd"); 
        System.out.println(file3.mkdirs());  //创建多级目录
    }
/**
     * 重命名注意事项:
     *         如果路径名相同,就是改名,不同就是改名并剪切
     * 删除注意事项:    
     *         java删除不走回收站
     *         要删除一个文件夹,注意该文件夹不能包含文件或者文件夹
     */
    public static void main(String[] args) {
        File file1 = new File("xxx.txt");
        File file2 = new File("ooo.txt");
        file1.renameTo(file2);              //把文件重命名为指定的文件路径
        
        File file3= new File("zzz");
        file3.delete();                    //删除文件
        
    }
public static void main(String[] args) {
        File file1 = new File("ccc");
        System.out.println(file1.isDirectory());    //判断是都是一个文件夹
        
        File file2 = new File("ooo.txt");
        System.out.println(file2.isFile());         //判断是否是文件
        
        File file3 = new File("eee");
        System.out.println(file3.exists());        //判断是否存在
        
        File file4 = new File("ooo.txt");
        file4.setReadable(false);
        System.out.println(file4.canRead());     //判断是否可读
        
        System.out.println(file4.canWrite());    //判断是否可写(window系统默认所有文件都是可读的)
        
        System.out.println(file4.isHidden());   //判断是否隐藏
    }
public static void main(String[] args) {
        File file1 = new File("ooo.txt");
        System.out.println(file1.getAbsolutePath());    //D:\myworkspace\demo\ooo.txt 获取绝对路径
        
        File file2 = new File("ooo.txt");
        File file3 = new File("D:\\myworkspace\\demo\\ooo.txt");
        System.out.println(file2.getPath());            //ooo.txt 获取构造方法传入的路径
        
        System.out.println(file3.getPath());             //D:\myworkspace\demo\ooo.txt 获取构造方法传入的路径
        
        System.out.println(file2.getName());           //ooo.txt 获取文件或者文件夹的名称
        
        System.out.println(file2.length());           //获取长度,字节数
        
        System.out.println(file2.lastModified());     //获取最后一次的修改时间(毫秒数)    
    }
public static void main(String[] args) {
        File dir = new File("D:\\Notepad++");
        String[] arr = dir.list();   //仅为了获取文件名
        for (String string : arr) {
            System.out.println(string);
        }

        File[] subFiles = dir.listFiles();  //获取文件对象
        for (File file : subFiles) {
            System.out.println(file);
        }
    }

 22.IO流

  1.字节流

public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("xxx.txt"); //创建流对象
        int x = fis.read();              //从硬盘上读取一个字节
        System.out.println(x);
        fis.close();                  //关流释放资源
    }
/**
     * FileOutputStream在创建对象时如果没有这个文件会创建出来,如果有这个文件会将文件清空
     */
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("yyy.txt");  //创建字节输出流对象,
        fos.write(98);        
        fos.close();
                
        FileOutputStream fos1 = new FileOutputStream("yyy.txt",true);  //如果想续写就在第二个参数传一个true
        fos1.write(99);
        fos1.close();

    }
/**
     * 一个一个字节读取和写 
     */
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("C:\\Users\\wisdytech\\Pictures\\Screenshots\\屏幕截图(1).png"); //创建输入流对象
        FileOutputStream fos = new FileOutputStream("copy.png");  //创建输出流对象
        int b;
        while((b=fis.read()) != -1){     //不断读取每一个字节
            fos.write(b);                //将每个字节写出
        }
        
        fis.close();
        fos.close();

    }
/**
     * 不推荐使用,因为可能会导致内存溢出 
     */
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("C:\\Users\\wisdytech\\Pictures\\Screenshots\\屏幕截图(1).png"); //创建输入流对象
        FileOutputStream fos = new FileOutputStream("copy1.png");  //创建输出流对象
        byte[] arr = new byte[fis.available()];   //创建与文件一样大小的字节数组
        fis.read(arr);                            //将文件上的字节读取到内存中
        fos.write(arr);                            //将字节数组中的字节数据写到文件中
        fis.close();
        fos.close();
    }

 

/**
     * 定义小数组(拷贝)
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        //demo1();
        FileInputStream fis = new FileInputStream("yyy.txt");
        FileOutputStream fos = new FileOutputStream("zzz.txt");
        
        byte[] arr = new byte[2];
        int len;
        while((len = fis.read(arr)) != -1){
            fos.write(arr,0,len);
        }
        fis.close();
        fos.close();

    }
    
    public static void demo1() throws IOException{
        FileInputStream fis = new FileInputStream("yyy.txt");
        byte[] arr = new byte[2];
        int a = fis.read(arr);       //将文件上的字节读取到字节数组中
        
        System.out.println(a);  // 2
        for(byte b:arr){
            System.out.println(b); //97 98
        }
        int c = fis.read(arr); 
        System.out.println(c); // 1
        for(byte b:arr){ 
            System.out.println(b); // 99 98
        }
        
        fis.close();
    }
/**
     * BufferedInputStream和BufferedOutputStream进行copy
     */
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("yyy.txt");   //创建输入流对象
        FileOutputStream fos = new FileOutputStream("zzz.txt"); //创建输出流对象
        BufferedInputStream bis = new BufferedInputStream(fis);  //创建缓冲区对象,对输入流进行包装,使其变得更强大
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        
        int b;
        while((b = bis.read()) != -1){
            bos.write(b);
        }
        
        bis.close();
        bos.close();

    }

close和flush区别

  close()方法:具备刷新功能,在关闭流之前,就会先刷新一次缓冲区,将缓冲区的字节全部刷新到文件上,

        在关闭,刷完之后就不能再写了

  flush()方法:具备刷新功能,刷完之后还可以继续写

 

/**
     * 字节流读取中文:
     *         字节流在读取中文时可能读到半个字节,导致乱码
     * 字节流写出中文的问题:
     *         字节流直接操作的字节,所以写出中文必须将字符串转换成字节数组
     *         写出回车换行write("\r\n".getBytes())
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        FileOutputStream fos  = new FileOutputStream("xxx.txt");
        fos.write("我读书少,你不要骗我".getBytes());
        fos.write("\r\n".getBytes());
        fos.close();

    }
    
    public static void demo1() throws IOException{
        FileInputStream fis = new FileInputStream("xxx.txt");
        byte[] arr = new byte[3];
        int len;
        while((len = fis.read(arr)) != -1){
            System.out.println(new String(arr,0,len));
        }
        
        fis.close();
    }

 2.字符流

/**
     * 读
     */
    public static void main(String[] args) throws IOException {
        //demo1();
        FileReader fr = new FileReader("zzz.txt");
        int x;
        while((x = fr.read()) != -1 ){
            char c =(char)x;
            System.out.print(c);
        }
        fr.close();
    }
    
    public static void demo1() throws IOException{
        FileReader fr = new FileReader("zzz.txt");
        int x = fr.read();
        char c =(char)x;
        System.out.println(c);
        fr.close();
    }
/**
     * 写
     */
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("aaa.txt");
        fw.write("好好学习,天天向上");
        fw.write(97);
        fw.close();
    }
/**
     * 带缓冲区的字符流(BufferedReader和BufferedWriter)
     */
    public static void main(String[] args) throws IOException {
        //demo1();
        //demo2();
        BufferedReader br = new BufferedReader(new FileReader("xxx.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("ccc.txt"));
        
        int c;
        while((c = br.read()) != -1){
            bw.write(c);
        }
        br.close();
        bw.close();
    }
    
    /**
     * 字符流不可以拷贝非纯文本的文件
     */
    public static void demo1() throws IOException{
        FileReader fr = new FileReader("xxx.txt");
        FileWriter fw = new FileWriter("ccc.txt");
        
        int x;
        while((x = fr.read()) != -1){
            fw.write(x);
        }
        
        fr.close();
        fw.close();

    }
    /**
     * 自定义字符数组拷贝
     */
    public static void demo2() throws IOException{
        FileReader fr = new FileReader("xxx.txt");
        FileWriter fw = new FileWriter("ddd.txt");
        
        char[] arr = new char[1024*8];
        int len;
        while((len = fr.read(arr)) != -1){  //将文件上的数据读取到字符数组中
            fw.write(arr,0,len);             //将字符数组中的数据写到文件上
        }
        fw.close();
    }
/**
     * 带缓冲区的流中的特殊方法
     * readLine() 整行读取(效率更高)
     * newLine()
     * 
     * newLine()与\r\n区别
     * newLine()是跨平台的方法
     * \r\n只支持window系统
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        //demo();
        BufferedReader br = new BufferedReader(new FileReader("xxx.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("ccc.txt"));
        
        String line;
        while((line = br.readLine()) != null){
            bw.write(line);
            //bw.newLine();        //写出回车换行符
            bw.write("\r\n");
        }
        bw.close();
    }
    
    public static void demo() throws IOException{
        BufferedReader br = new BufferedReader(new FileReader("xxx.txt"));
            
        String line;
        
        while((line = br.readLine()) != null){
            System.out.println(line);
        }
        br.close();
    }

 

/**
     * 将一个文本档上的文本反转
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        //1。创建输入输出流
        BufferedReader br = new BufferedReader(new FileReader("xxx.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("bbb.txt"));
        //2.创建集合对象
        List<String> list = new ArrayList<>();
        //3.将读取的数据存储在集合中
        String line;
        while((line = br.readLine()) != null){
            list.add(line);
        }
        //4.倒着遍历集合将数据写到文件上
        for(int i=list.size()-1;i>=0;i--){
            bw.write(list.get(i));
            bw.newLine();
        }
        bw.close();
        br.close();
        
    }
/**
     * 增加行号读取
     * 
     */
    public static void main(String[] args) throws IOException {
        LineNumberReader lnr = new LineNumberReader(new FileReader("xxx.txt"));
        String line;
        lnr.setLineNumber(100);
        while((line = lnr.readLine()) != null){
            System.out.println(lnr.getLineNumber() + ":" + line);
        }
        lnr.close();

    }
public class Wrap {

    /**
     * 装饰设计模式
     * 耦合性不强,被装饰的类的变化与装饰类的变化无关
     */
    public static void main(String[] args) {
        HeiMaStudent hms = new HeiMaStudent(new Student());
        hms.code();

    }

}

interface Coder{
    public void code();
}

class Student implements Coder{

    @Override
    public void code() {
        System.out.println("javase");
        System.out.println("javaweb");
    }
    
}

class HeiMaStudent implements Coder{
    //1.获取被装饰类的引用
    private Student s;        //获取学生引用
    
    //2.在构造方法中传入被装饰类的对象
    public HeiMaStudent(Student s){
        this.s =s;
    }
    
    //3.对原有的功能进行升级
    @Override
    public void code() {
        s.code();
        System.out.println("ssh");
        System.out.println("数据库");
        System.out.println("大数据");
        System.out.println("...");
        
    }    
}

 

/**
     * 高效使用指定编码表读写
     */
    public static void main(String[] args) throws IOException {
        //demo1();
        //demo2();
        BufferedReader br =    //更高效的读
                new BufferedReader(new InputStreamReader(new FileInputStream("utf-8.txt"),"utf-8"));
        BufferedWriter bw =     //更高效的写
                new BufferedWriter(new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk"));
        int c;
        while((c = br.read()) != -1){
            bw.write(c);
        }
        bw.close();        
        
                
    }
    /**
     * 用默认编码表读写。出现乱码
     */
    public static void demo1() throws IOException{
        //用默认编码表读写。出现乱码
        FileReader fr = new FileReader("utf-8.txt");
        FileWriter fw = new FileWriter("gbk.txt");
        
        int c;
        while((c = fr.read()) != -1){
            fw.write(c);
        }
        fw.close();
    }
    /**
     * 用指定编码表读写
     */
    public static void demo2() throws IOException{
        //指定码表读字符
        InputStreamReader isr = new InputStreamReader(new FileInputStream("utf-8.txt"),"utf-8");
        //指定码表写字符
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk");
        int c;
        while((c = isr.read()) != -1){
            osw.write(c);
        }
        osw.close();
                        
    }

 转换流图解

/**
     * 获取文本上每个字符出现的次数,将结果写在time。txt上
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        //1.创建带缓冲的输入流对象
        BufferedReader br = new BufferedReader(new FileReader("xxx.txt"));
        //2.创建双列集合对象TreeMap
        TreeMap<Character, Integer> tm = new TreeMap<>();
        //3.将读到的字符串存储到双列集合中,存储时要判断,如果不包含这个键,将键和1存储,如果包含这个键,将该键和值加1存储
        int ch;
        while((ch = br.read()) != -1){
            char c = (char)ch;   //向下强转
            /*if(! tm.containsKey(c)){
                tm.put(c, 1);
            }else{
                tm.put(c, tm.get(c) + 1);
            }*/
            tm.put(c, ! tm.containsKey(c) ? 1:tm.get(c) + 1);
            
        }
        
        //4.关闭输入流
        br.close();
        //5.创建输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("times.txt"));
        //6.遍历集合将集合中的内容写到time.txt中
        for(Character key :tm.keySet()){
            switch (key) {
            case '\t':
                bw.write("\\t" + "=" + tm.get(key));
                break;
            case '\n':
                bw.write("\\n" + "=" + tm.get(key));
                break;
            case '\r':
                bw.write("\\r" + "=" + tm.get(key));
                break;
            default:
                bw.write(key + "=" + tm.get(key));
                break;
            }
            bw.newLine();
        }
        //7.关闭输出流
        bw.close();
    }

 

/**
     * 试用版软件,试用10次,次数到了购买正版
     */
    public static void main(String[] args) throws IOException {
        //1.创建带缓冲的输入流对象,要使用readLine方法,保证数据的原样性
        BufferedReader br = new BufferedReader(new FileReader("config.txt"));
        //2.将读到的字符串转为int数
        String line = br.readLine();
        int times = Integer.valueOf(line);
        //3.对int数进行判断,如果大于0,将其--写回去,如果不大于0,就提示请购买正版
        if(times > 0){
            //4.在if判断中将--的结构打印,并将结果通过输出流写到文件上
            System.out.println("您还有"+times--+"次机会");
            FileWriter fw = new FileWriter("config.txt");
            fw.write(times+"");
            fw.close();
        }else{
            System.out.println("您的试用次数已到");
        }
        br.close();
    }

 递归:

/**
     * 递归:方法自己调用自己
     * 实现5的阶乘
     */
    public static void main(String[] args) {
        int sum = fun(5);
        System.out.println(sum);
    }
    
    public static int fun(int num){
        if(num == 1){
            return 1;
        }else {
            return num*fun(num-1);
        }
    }
/**
     * 从键盘输入接收一个文件夹路径,打印出该文件夹下所有的.java文件名
     * 分析:
     *     从键盘接收一个文件夹路径
     *      1.如果录入的是不存在,给与提示
     *      2.如果录入的是文件路径,给与提示
     *      3.如果是文件夹路径,直接返回
     *  打印出该文件夹下所有的.java文件名
     *   1.获取到该文件夹路径下的所有文件和文件夹,存储在File数组中
     *   2.遍历数组,对每一个文件或文件夹做判断
     *   3.如果是文件,并且后缀是。java就打印
     *   4.如果是文件夹,就递归调用
     *     
     */
    public static void main(String[] args) {
        File fir = getDir();
        getJavaFile(fir);
    }
    
    /**
     * 键盘录入获取文件夹
     */
    public static File getDir(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入路径");
        while(true){
            String line = sc.nextLine();
            File fir = new File(line);
            if(! fir.exists()){
                System.out.println("输入的路径不存在");
            }else if(fir.isFile()){
                System.out.println("输入路径不是文件夹路径");
            }else{
                return fir;
            }
        }                    
    }
    /**
     * 获取所有.java文件
     */
    public static void getJavaFile(File fir){
        //1.获取到该文件夹路径下的所有文件和文件夹,存储在File数组中
        File[] fileArr = fir.listFiles();
        //2.遍历数组,对每一个文件或文件夹做判断
        for(File subFil:fileArr){
            //3.如果是文件,并且后缀是。java就打印
            if(subFil.isFile() && subFil.getName().endsWith(".java")){
                System.out.println(subFil);
            //4.如果是文件夹,就递归调用
            }else if(subFil.isDirectory()){
                getJavaFile(subFil);
            }
        }
    }

 线程

public class Thread_Demo {

    /**
     *    Thread
     */
    public static void main(String[] args) {
        MyThread mt = new MyThread(); //4.创建Thread类的子类对象
        mt.start();                     //开启线程
        for(int i=0;i<1000;i++){
            System.out.println("bbbbbbbbb");
        }

    }

}

class MyThread  extends Thread{      //1.继承Thread方法
    public void run(){                 //2.重写run方法
        for(int i=0;i<1000;i++){     //3.将要执行的代码写在run方法中
            System.out.println("aaaaaaaaa");
        }
    }
    
}
public class Thread_demo2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        Thread t = new Thread(mr);
        t.start();
        
        for(int i=0;i<1000;i++){
            System.out.println("bbbbbbbbb");
        }

    }

}

class MyRunnable implements Runnable{  //1.定义一个类实现Runnable

    @Override
    public void run() {                //2.重写run方法
        for(int i=0;i<1000;i++){     //3.将要执行的代码写在run方法中
            System.out.println("aaaaaaaaa");
        }
        
    }
    
}
public class Synchronized_Demo1 {

    /**
     * 同步代码块
     * 当多线程并发,有多段代码同时执行时,我们希望某一段代码执行过程中cpu不要切换到其他流程工作,这时就需要同步
     * 如果两段代码是同步的,那么同一时间只能执行一段,在一段代码没执行结束之前,不会执行另一段代码
     */
    public static void main(String[] args) {
        final Printer p = new Printer();
        /**
         * 匿名内部类创建线程
         */
        new Thread(){
            public void run(){
                while(true){
                    p.print1();
                }
            }
        }.start();
        
        new Thread(){
            public void run(){
                while(true){
                    p.print2();
                }
            }
        }.start();
    }

}

class Printer{
    Demo d =new Demo();
    public void print1(){
        synchronized(d) {                    //同步代码块,锁机制,锁对象可以是任意的
            System.out.print("黑");
            System.out.print("马");
            System.out.print("程");
            System.out.print("序");
            System.out.print("员");
        
        }
    }
    public void print2(){
        synchronized(d) {
            System.out.print("传");
            System.out.print("智");
            System.out.print("播");
            System.out.print("客");
            System.out.print("\r\n");
        }
    }
}

class Demo{
    
}
public class Synchronized_Demo2 {

    /**
     * 同步方法
     */
    public static void main(String[] args) {
        final Printer2 p = new Printer2();
        /**
         * 匿名内部类创建线程
         */
        new Thread(){
            public void run(){
                while(true){
                    p.print1();
                }
            }
        }.start();
        
        new Thread(){
            public void run(){
                while(true){
                    p.print2();
                }
            }
        }.start();
    }

}

class Printer2{
    Demo1 d =new Demo1();
    //非静态同步方法的锁对象是this
    //静态同步方法的锁对象是该类的字节码类.class
    public synchronized void print1(){

            System.out.print("黑");
            System.out.print("马");
            System.out.print("程");
            System.out.print("序");
            System.out.print("员");
        
    }
    public void print2(){
        synchronized(this) {
            System.out.print("传");
            System.out.print("智");
            System.out.print("播");
            System.out.print("客");
            System.out.print("\r\n");
        }
    }
}

class Demo1{
    
}
public class Test1 {

    /**
     * 多线程并发处理同一数据时,就有可能出现线程安全问题
     * 使用同步技术可以解决这种问题
     * 铁路售票,一共100张,通过4个窗口卖完
     */
    public static void main(String[] args) {
        new Ticket().start();
        new Ticket().start();
        new Ticket().start();
        new Ticket().start();

    }

}

class Ticket extends Thread{
    private static int ticket = 100;  //new Ticket()是四个不同的对象,当成员变量为静态的4个对象会共享
    public void run(){
        while(true){
            synchronized (Ticket.class) {
                if(ticket == 0){
                    break;
                }
            
                System.out.println(getName()+"这是第"+ ticket-- +"号票" );
            }
            
        }
    }
}
public class Test2 {

    /**
     * 铁路售票,一共100张,通过4个窗口卖完用Runnable接口
     */
    public static void main(String[] args) {
        MyTicket mt = new MyTicket();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();

    }

}

class MyTicket implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
        while(true){
            synchronized (Ticket.class) {
                if(ticket == 0){
                    break;
                }
            
                System.out.println(Thread.currentThread().getName()+"这是第"+ ticket-- +"号票" );
            }
            
        }
    }
    
}
public class DeadLock {

    /**
     * 死锁(synchronized嵌套synchronized)
     */
    private static String s1="筷子左";
    private static String s2="筷子右";
    
    public static void main(String[] args) {
        new Thread(){
            public void run(){
                while(true){
                    synchronized (s1) {
                        System.out.println(getName()+"获取"+ s1 +"等待" +s2);
                        synchronized(s2){
                            System.out.println(getName()+"拿到"+ s2 +"开吃");
                        }
                    }
                }
            }
        }.start();
        
        new Thread(){
            public void run(){
                while(true){
                    synchronized (s2) {
                        System.out.println(getName()+"获取"+ s2 +"等待" +s1);
                        synchronized(s1){
                            System.out.println(getName()+"拿到"+ s1 +"开吃");
                        }
                    }
                }
            }
        }.start();

    }

}

 单例设计模式

public class Singleton_Demo {

    /**
     * 单例设计模式(保证类在内存中只有一个对象)
     */
    public static void main(String[] args) {
        //Singleton s1 = new Singleton(); 不能创建
        
        //成员变量被私有不能通过类名.调用
        /*Singleton s1 = Singleton.s;
        Singleton s2 = Singleton.s;    
        System.out.println(s1=s2); //true
        */    
        
        /*Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1==s2);*/
        
        
        Singleton s1 = Singleton.s;
        Singleton s2 = Singleton.s;    
        System.out.println(s1==s2);
        
    }

}

/**
 * 饿汉式(直接创建对象)
 */
/*class Singleton{
    //1.私有构造方法,其他类不能访问该构造方法
    private Singleton(){}
    //2.创建本类对象
    private static Singleton s = new Singleton();
    //3.对外提供公共的访问方法
    public static Singleton getInstance(){ //获取实例
        return s;
    }

}*/

/**
 * 懒汉式(开发时不用) 单例的延迟加载模式
 */
/*class Singleton{
    //1.私有构造方法,其他类不能访问该构造方法
    private Singleton(){}
    //2.创建本类对象
    private static Singleton s;
    //3.对外提供公共的访问方法
    public static Singleton getInstance(){ //获取实例
        if(s == null){
            //多线程访问时会创建多个对象
            s = new Singleton();
        }
        return s;
    }

}*/
/*
 *饿汉式和懒汉式区别
 * 1.饿汉式是空间换时间,懒汉式是时间换空间
 * 2.在多线程访问时,饿汉式不会创建多个对象,而懒汉式有可能会创建多个对象
 */


/** 
 *    第三种
 */
class Singleton{
    //1.私有构造方法,其他类不能访问该构造方法
    private Singleton(){}
    //2.创建本类对象
    public static final Singleton s = new Singleton();
    

}

计时器

 

public class Timer_Demo {

    /**
     * 计时器
     * @throws Exception 
     */
    public static void main(String[] args) throws Exception {
        Timer t = new Timer();
        //在指定时间安排指定任务
        //第一个参数是安排的任务,第二个参数是执行的时间,第三个参数是过多长时间在重复执行
        t.schedule(new MyTimerTask(), new Date(188, 6, 1, 14, 20, 30),3000);
        while(true){
            Thread.sleep(1000);
            System.out.println(new Date());
        }
    }

}

class MyTimerTask extends TimerTask{

    @Override
    public void run() {
        System.out.println("起床背英语单词");
    }
    
    
}

 

线程间的通信

 

public class Notify_demo {

    /**
     * 线程间通信
     * 等待唤醒机制
     */
    public static void main(String[] args) {
        final Printer2 p = new Printer2();
        new Thread() {
            public void run(){
                while(true){
                    try {
                        p.print1();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
        
        new Thread() {
            public void run(){
                while(true){
                    try {
                        p.print2();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();

    }

}
//等待唤醒机制
//实现将黑马程序员、传智播客间隔输出
class Printer2{
    private int flag =1;
    public void print1() throws InterruptedException{
        synchronized(this) {
            if(flag != 1){
                this.wait();
            }
            System.out.print("黑");
            System.out.print("马");
            System.out.print("程");
            System.out.print("序");
            System.out.print("员");
            System.out.print("\r\n");
            
            flag =2;
            this.notify(); //随机唤醒单个等待的线程
        }
        
    }
    public void print2() throws InterruptedException{
        synchronized(this) {
            if(flag != 2){
                this.wait();        //当前线程等待
            }
            System.out.print("传");
            System.out.print("智");
            System.out.print("播");
            System.out.print("客");
            System.out.print("\r\n");
            
            flag =1;
            this.notify();
        }
    }
}

 

public class NotifyAll_Demo {

    /**
     * 三个或三个以后线程通信
     */
    public static void main(String[] args) {
        final Printer3 p = new Printer3();
        new Thread() {
            public void run(){
                while(true){
                    try {
                        p.print1();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
        
        new Thread() {
            public void run(){
                while(true){
                    try {
                        p.print2();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
        
        new Thread() {
            public void run(){
                while(true){
                    try {
                        p.print3();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();


    }

}

/**
 * 再同步代码块中,用哪个对象锁,就用哪个对象调用wait方法
 * sleep方法和wait方法区别:
 *     sleep方法必须传入参数,参数就是时间,时间到了自动醒来
 *     wait方法可以传入参数也可以不传入参数,传入参数就是在参数的时间结束后等待,不传入参数就是直接等待
 *  sleep方法在同步函数或同步代码中,不释放锁
 *  wait方法在同步函数或同步代码中,释放锁
 *
 */
class Printer3{
    private int flag =1;
    public void print1() throws InterruptedException{
        synchronized(this) {
            while(flag != 1){
                this.wait();
            }
            System.out.print("黑");
            System.out.print("马");
            System.out.print("程");
            System.out.print("序");
            System.out.print("员");
            System.out.print("\r\n");
            
            flag =2;
            this.notifyAll(); //随机唤醒单个等待的线程
        }
        
    }
    public void print2() throws InterruptedException{
        synchronized(this) {
            while(flag != 2){
                this.wait();        //当前线程等待
            }
            System.out.print("传");
            System.out.print("智");
            System.out.print("播");
            System.out.print("客");
            System.out.print("\r\n");
            
            flag =3;
            this.notifyAll();
        }
    }
    public void print3() throws InterruptedException{
        synchronized(this) {
            while(flag != 3){
                this.wait();        //当前线程等待
            }
            System.out.print("i");
            System.out.print("t");
            System.out.print("h");
            System.out.print("e");
            System.out.print("i");
            System.out.print("m");
            System.out.print("e");
            System.out.print("\r\n");
        
            flag =1;
            this.notifyAll();
        }
    }
}
public class ReentrantLock_demo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        final Printer4  p = new Printer4();
        new Thread() {
            public void run(){
                while(true){
                    try {
                        p.print1();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
        
        new Thread() {
            public void run(){
                while(true){
                    try {
                        p.print2();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
        
        new Thread() {
            public void run(){
                while(true){
                    try {
                        p.print3();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();


    }


}
class Printer4{
    private ReentrantLock r = new ReentrantLock();
    private Condition c1 = r.newCondition();
    private Condition c2 = r.newCondition();
    private Condition c3 = r.newCondition();
    private int flag =1;
    public void print1() throws InterruptedException{
            r.lock();        //获取锁
            if(flag != 1){
                c1.await();
            }
            System.out.print("黑");
            System.out.print("马");
            System.out.print("程");
            System.out.print("序");
            System.out.print("员");
            System.out.print("\r\n");
            
            flag =2;
            c2.signal();
            r.unlock();        //释放锁
        
    }
    public void print2() throws InterruptedException{
            r.lock();        //获取锁
            if(flag != 2){
                c2.await();        //当前线程等待
            }
            System.out.print("传");
            System.out.print("智");
            System.out.print("播");
            System.out.print("客");
            System.out.print("\r\n");
            
            flag =3;
            c3.signal();
            r.unlock();        //释放锁
    }
    public void print3() throws InterruptedException{
            r.lock();        //获取锁
            if(flag != 3){
                c3.await();        //当前线程等待
            }
            System.out.print("i");
            System.out.print("t");
            System.out.print("h");
            System.out.print("e");
            System.out.print("i");
            System.out.print("m");
            System.out.print("e");
            System.out.print("\r\n");
        
            flag =1;
            c1.signal();
            r.unlock();        //释放锁
    }
}
public class ThreadGroup_demo {
    public static void main(String[] args) {
        //demo();
        
        ThreadGroup tg = new ThreadGroup("我是一个新的线程组"); //创建新的线程组
        MyRunnable mr = new MyRunnable();    //创建Runnable子类对象
        Thread t1 = new Thread(tg, mr, "张三");    //将线程t1放在组中
        Thread t2 = new Thread(tg, mr, "李四");    //将线程t2放在组中
        
        System.out.println(t1.getThreadGroup().getName()); //获取组名
        System.out.println(t2.getThreadGroup().getName());
        
        
    }
    
    public static void demo(){
        MyRunnable mr = new MyRunnable();
        Thread t1 = new Thread(mr, "张三");
        Thread t2 = new Thread(mr, "李四");
        
        ThreadGroup tg1 = t1.getThreadGroup();
        ThreadGroup tg2 = t2.getThreadGroup();
        System.out.println(tg1.getName());    //main 默认是主线程
        System.out.println(tg2.getName());
    }
    
}

class MyRunnable implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<1000;i++){
            System.out.println(Thread.currentThread().getName());
        }
        
    }
    
}

 简单工厂模式

 

/**
 * Cat类
 */
public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

}
------------------------------------------------------
/**
 * Dog类
 */
public class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("狗吃肉");

    }

}
------------------------------------------------------
/**
 * Animal类
 */
public abstract class Animal {
    public abstract void eat();
}
------------------------------------------------------
/**
 * 工厂类
 */
public class AnimalFactory {
    /*public static Dog createDog(){
        return new Dog();
    }
    
    public static Cat createCat(){
        return new Cat();
    }*/
    
    //发现方法会定义很多,复用性太差
    //改进
    public static Animal createAnima(String name){
        if("dog".equals(name)){
            return new Dog();
        }else if ("cat".equals(name)){
            return new Cat();
        }else{
            return null;
        }
    }
}
------------------------------------------------------
public class Test {

    /**
     * 简单工厂模式(定义一个具体的工厂类负责创建一些类的实例)
     *     优点:客户端不需要负责对象的创建,从而明确了各个类的职责
     *     缺点:这个静态工厂类负责所有对象的创建,如果有新的对象增加,或者其他对象的创建方式不同,
     *         就需要不断的修改工厂类,不利于后期的维护
     */
    public static void main(String[] args) {
        //Dog d = AnimalFactory.createDog();

        Dog d = (Dog) AnimalFactory.createAnima("dog");
        d.eat();
        
        Cat c = (Cat) AnimalFactory.createAnima("cat");
        c.eat();
    }

}

 

工厂方法模式

 

public abstract class Animal {
    public abstract void eat();
}
-------------------------------------
public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

}
--------------------------------------------
public class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("狗吃肉");

    }

}
------------------------------------------------
public interface Factory {
    public Animal createAnimal();
    
}
-------------------------------------------------
public class CatFactory implements Factory {

    @Override
    public Animal createAnimal() {
        
        return new Cat();
    }

}
-----------------------------------------------------
public class DogFactory implements Factory {

    @Override
    public Animal createAnimal() {
        return new Dog();
    }

}
---------------------------------------------------------------
public class Test {

    /**
     * 工厂方法模式(抽象工厂类负责定义创建对象的接口,具体对象的创建工作由继承工厂的具体类实现)
     *     优点:客户端不需要负责对象的创建,从而明确各个类的职责,只需要增加一个具体类和具体的工厂类即可
     *         不影响已有的代码,后期维护容易,增加了系统的扩展性
     *     缺点:需要额外的编写代码。增加了工作量
     */
    public static void main(String[] args) {
        DogFactory df = new DogFactory();
        Dog d = (Dog) df.createAnimal();
        d.eat();
        
        CatFactory cf = new CatFactory();
        Cat c = (Cat) cf.createAnimal();
        c.eat();

    }

}

GUI(图形用户接口)

适配器设计模式:

  适配器:在使用监听器的时候,需要定义一个类事件监听器接口

      通常接口中会有多个方法,而程序中不一定所有都用到

      但又必须重写,这很繁琐,适配器简化了这些操作,

      我们定义监听器时只要继承适配器,然后重写需要的方法即可

  适配器原理:就是一个类,实现了监听器接口,所有抽象方法都重写了

        但方法都是空的,

        适配器类需要定义为抽象的,因为创建该类对象,调用空方法是没有意义的

        目的就是为了简化程序员的操作,定义监听器时继承适配器,只重写需要的方法即可

public class Demo1_Adapter {

    /**
     * 适配器设计模式
     */
    public static void main(String[] args) {
        luzhishen lzs = new luzhishen();
        lzs.xiwu();
        
    }

}

interface heshang{
    public void dazuo();
    public void nianjing();
    public void zhuangzhong();
    public void xiwu();
}

//声明称抽象的原因是:不想让其他类创建本类对象,因为创建也没有意义,方法都是空的
abstract class tiangangxing implements heshang{

    @Override
    public void dazuo() {
    }
    
    @Override
    public void nianjing() {
    }

    @Override
    public void zhuangzhong() {
    }

    @Override
    public void xiwu() {
    }
    
}

class luzhishen extends tiangangxing{
    public void xiwu(){
        System.out.println("拳打镇关西");
        System.out.println("倒拔垂杨柳");
    }
}

 网络编程

 upd传输

/**
     * 发送
     */
    public static void main(String[] args) throws Exception {
        String str = "what are you doing";
        DatagramSocket socket = new DatagramSocket(); //随机端口号
        DatagramPacket packet = new DatagramPacket(str.getBytes(),
                str.getBytes().length,InetAddress.getByName("127.0.0.1"),6666);
        socket.send(packet);
        socket.close();

    }
--------------------------------------------------------------


/**
     * 接收
     */
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(6666);
        DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);
        socket.receive(packet);
        
        byte[] arr = packet.getData();    //获取数据
        int len = packet.getLength();  //获取有效的字节个数
        String ip = packet.getAddress().getHostAddress();
        int port = packet.getPort();
        System.out.println(ip +"----"+port+"----"+new String(arr, 0, len));
        socket.close();
    }

 TCP

/**
     * 客户端
     *     创建Socket连接服务器(指定ip地址,端口号)通过ip地址找对应的服务器
     *     调用Socket的getInputStream和getOutputStream方法获取和服务端相连的IO流
     *  输入流可以读取服务器输出流写出的数据
     *  输出流可以写出数据到服务端的输入流
     */
    public static void main(String[] args) throws UnknownHostException, IOException {
        Socket socket = new Socket("127.0.0.1", 12345);        
        
        InputStream is = socket.getInputStream(); //获取客户端输入流
        OutputStream os = socket.getOutputStream(); //获取客户端输出流    
        
        byte[] arr =new byte[1024];
        int len = is.read(arr);        //读取服务器发过来的数据
        System.out.println(new String(arr,0,len));  //将数据转换成字符串并打印    
        
        os.write("学习挖掘机哪家强".getBytes());    //客户端向服务器写数据        
        socket.close();
    }
/**
     * 服务端
     *  创建ServerSocket(需指定端口号)
     *  ServerSocket的accept方法接受一个客户端请求,得到一个Socket
     *  调用Socket的getInputStream和getOutputStream方法获取和客户端相连的IO流
     *  输入流可以读取客户端输出流写出的数据
     *  输出流可以写出数据到客户端的输入流
     */
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(12345);
        Socket socket = server.accept();
        
        InputStream is = socket.getInputStream(); //获取客户端输入流
        OutputStream os = socket.getOutputStream(); //获取客户端输出流
        os.write("百度一下你就知道".getBytes());        //服务器向客户端写出数据
        
        byte[] arr =new byte[1024];
        int len = is.read(arr);        //读取客户端发过来的数据
        System.out.println(new String(arr,0,len));  //将数据转换成字符串并打印
        socket.close();
    }
/**
     * 客户端(优化版)
     *     创建Socket连接服务器(指定ip地址,端口号)通过ip地址找对应的服务器
     *     调用Socket的getInputStream和getOutputStream方法获取和服务端相连的IO流
     *  输入流可以读取服务器输出流写出的数据
     *  输出流可以写出数据到服务端的输入流
     */
    public static void main(String[] args) throws UnknownHostException, IOException {
        Socket socket = new Socket("127.0.0.1", 12345);        
        
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream())); //将字节流包装成字符流
        PrintStream ps = new PrintStream(socket.getOutputStream()); //printStream中有写出换行的方法
        
        System.out.println(br.readLine());
        ps.println("我想报名");
        System.out.println(br.readLine());
        ps.println("大哭");
        socket.close();
    }
/**
     * 服务端(优化版)
     *  创建ServerSocket(需指定端口号)
     *  ServerSocket的accept方法接受一个客户端请求,得到一个Socket
     *  调用Socket的getInputStream和getOutputStream方法获取和客户端相连的IO流
     *  输入流可以读取客户端输出流写出的数据
     *  输出流可以写出数据到客户端的输入流
     */
    public static void main(String[] args) throws IOException {
        //demo1();
        ServerSocket server = new ServerSocket(12345);
        while(true){
            final Socket socket = server.accept();
            new Thread(){
                public void run(){
                    try {
                        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream())); //将字节流包装成字符流
                        PrintStream ps;
                        ps = new PrintStream(socket.getOutputStream()); //printStream中有写出换行的方法
                         ps.println("欢迎咨询黑马程序员");
                            System.out.println(br.readLine());
                            ps.println("不好意思");
                            System.out.println(br.readLine());
                            socket.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } 
                    
                   
                }
            }.start();
            
        }
    }
    
    /**
     * 非线程
     */
    public static void demo1() throws IOException{
        ServerSocket server = new ServerSocket(12345);
        Socket socket = server.accept();
        
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream())); //将字节流包装成字符流
        PrintStream ps = new PrintStream(socket.getOutputStream()); //printStream中有写出换行的方法
        
        ps.println("欢迎咨询黑马程序员");
        System.out.println(br.readLine());
        ps.println("不好意思");
        System.out.println(br.readLine());
        socket.close();
    }

/**
     * 客户端向服务端写字符串(键盘录入),服务端(多线程)将字符串反转并写回,客户端再次读取到是反转后字符串
     * @throws IOException 
     * @throws UnknownHostException 
     */
    public static void main(String[] args) throws UnknownHostException, IOException {
        Scanner sc = new Scanner(System.in);
        
        Socket socket  = new Socket("127.0.0.1", 12345);
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        PrintStream ps = new PrintStream(socket.getOutputStream());
        
        ps.println(sc.nextLine());
        System.out.println(br.readLine());
        socket.close();

    }
-------------------------------------------------
/**
     * 服务端
     */
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(12345);
        while(true){
            final Socket socket = server.accept();
            new Thread(){
                public void run(){
                    try {
                        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                        PrintStream ps = new PrintStream(socket.getOutputStream());
                        
                        String line = br.readLine();
                        line = new StringBuilder(line).reverse().toString();
                        ps.println(line);
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    
                }
                
            }.start();
        }

    }
 
  

 

/**
     *客户端向服务端上传文件
     */
    public static void main(String[] args) throws UnknownHostException, IOException {
        //1.提示输入要上传的文件路径,验证路径是否存在以及是否是文件夹
        File file = getFile();
        //2.发送文件名到服务器
        Socket socket= new Socket("127.0.0.1", 12564);
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        PrintStream ps = new PrintStream(socket.getOutputStream());
        ps.println(file.getName());
        //6.接收结果,如果存在给予提示,程序直接退出
        String result =br.readLine();    //读取存在或者不存在的结果
        if("存在".equals(result)){
            System.out.println("您上传的文件已经存在,请不要重复上传");
            socket.close();
            return;
        }
        
        //7.如果不存在,定义FileInputStream读取文件,写出到网络
        FileInputStream fis = new FileInputStream(file);
        byte[] arr = new byte[8192];
        int len;
        
        while((len= fis.read(arr)) != -1){
            ps.write(arr,0,len);
        }
        fis.close();
        socket.close();

    }
    
    private static File getFile(){
        Scanner sc  =new Scanner(System.in); //创建键盘录入对象
        System.out.println("请输入文件路径");
        while(true){
            String line = sc.nextLine();
            File file = new File(line);
            if(! file.exists()){
                System.out.println("您录入的文件路径不存在,请重新录入");
            }else if(file.isDirectory()){
                System.out.println("您录入的是文件夹路径,请输入一个文件路径");
            }else {
                return file;
            }
        }
    }
------------------------------------------------
/**
     * 服务端
     */
    public static void main(String[] args) throws IOException {

        //3.创建多线程服务器
        ServerSocket server = new ServerSocket(12564);
        
        //4.读取文件名
        while(true){
            final Socket socket = server.accept(); //接收请求
            new Thread(){
                public void run(){
                    try {
                        InputStream is = socket.getInputStream();
                        BufferedReader br = new BufferedReader(new InputStreamReader(is));
                        PrintStream ps = new PrintStream(socket.getOutputStream());
                        String fileName = br.readLine(); 
                        
                        //判断文件是否存在,将结果返回客户端
                        File dir = new File("update");
                        dir.mkdir();    //创建文件夹
                        File file = new File(dir, fileName); //分装成file对象
                        if(file.exists()){
                            ps.println("存在");  //如果服务器已经存在这个文件将存在写给客户端
                            socket.close();        //关闭socket
                            return;
                        }else{
                            ps.println("不存在");
                            
                        }
                        //8.定义FileOutPrintStream 从网络读取数据,存储到本地
                        FileOutputStream fos = new FileOutputStream(file);
                        byte[] arr = new byte[8192];
                        int len;
                        while((len = is.read(arr)) != -1){
                            fos.write(arr,0,len);
                        }
                        fos.close();
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    
                }
                
            }.start();
            
        }
        
        
        
    }

 

 
 

转载于:https://www.cnblogs.com/zhuwenxia/p/9296211.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值