public class hello{
    public static void main(String[] args){
        System.out.println("fe");
    }
}

System.out.println(System.getProperty("user.dir"));

import java.util.Random;
public class hello{
    public static void main(String[] args){
        Random r=new Random();
// 生成 0 到 10（不包括10）之间的随机整数
        int num=r.nextInt(10);
        System.out.println(num);
    }
}

//构造
String s1 = "Runoob";              // String 直接创建
String s2 = new String("Runoob");   // String 对象创建
String s3 = s1;                    // 相同引用
int len = s1.length();    //长度
//访问字符
//访问要s1.charAt(0),不能s1[0];
//格式化
String s=String.format("%d",2);
System.out.println(s);
//拼接字符串、数字、字符
s1="我的名字是 ".concat("Runoob");
s2+="abc";
s2+=123;        //字符串+数字，数字会转成字符串
s2+='c';
//根据指定字符串分割
s="1,2,3";
String arr[]=s.split(",");
//字符串翻转要自己写
//数字转String
String s=String.valueOf(12);
//String转数字
int c=Integer.parseInt(s);
//String转Integer转数字
int c=Integer.valueOf(s).intValue();

//比较地址
//只要new，就在堆内存开辟空间。直接赋值字符串在常量池里。
        String str1 = "hello";        //常量池里无“hello”对象，创建“hello”对象，str1指向常量池“hello”对象。
//先检查字符串常量池中有没有"hello"，如果字符串常量池中没有，则创建一个，然后 str1 指向字符串常量池中的对象，如果有，则直接将 str1 指向"hello"；
        String str2 = "hello";    //常量池里有“hello”对象，str2直接指向常量池“hello”对象。
        String str3 = new String("hello");   //堆中new创建了一个对象。假如“hello”在常量池中不存在，Jvm还会常量池中创建这个对象“hello”。
        String str4 = new String("hello");
        System.out.println(str1==str2);//true，因为str1和str2指向的是常量池中的同一个内存地址
        System.out.println(str1==str3);//fasle，str1常量池旧地址，str3是new出的新对象，指向一个全新的地址
        System.out.println(str4==str3);//fasle，因为它们引用不同
 
//比较内容
        System.out.println(str4.equals(str3));//true，因为String类的equals方法重写过，比较的是字符串值

//构造
        StringBuilder sb= new StringBuilder("abc");
//String转StringBuilder
        sb.append("d").append("e").append("f");
//StringBuilder转String
        String s=sb.toString();
//反转
        sb.reverse();

import java.util.ArrayList;
public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        System.out.println(sites);        //[Google, Runoob, Taobao, Weibo]
        System.out.println(sites.get(1));  // 访问第二个元素Runoob
        sites.set(2, "Wiki"); // 第一个参数为索引位置，第二个为要修改的值
        sites.remove(3); // 删除第四个元素
        System.out.println(sites.size());//计算大小
    }
}

//StudentManager.java
package package_test;
import java.util.Scanner;
import java.util.ArrayList;
public class StudentManager {
    public static void main(String args[]) {
        Scanner sc=new Scanner(System.in);
        ArrayList<Student> al = new ArrayList<>();
        while (true) {
            System.out.println("1增加学生，2删除学生，3修改学生，4查询学生，5退出系统");
            int choose = sc.nextInt();
            switch (choose) {
                case 1:
                    add(al);
                    break;
                case 2:
                    delete(al);
                    break;
                case 3:
                    update(al);
                    break;
                case 4:
                    search(al);
                    break;
                default:
                    System.exit(0);
            }
        }
    }
    public static void add(ArrayList<Student> al) {      //必须是静态方法，否则报错
        System.out.println("input id:");
        Scanner sc = new Scanner(System.in);
        Student child = new Student();
        String id = sc.nextLine();
        child.setId(id);
        System.out.println("input name: ");
        String name = sc.nextLine();
        child.setName(name);
        al.add(child);
    }
    public static void search(ArrayList<Student> al) {
        if (al.size() == 0) System.out.println("no information");
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < al.size(); i++) System.out.println(al.get(i).getId() + " " + al.get(i).getName());
    }
    public static void update(ArrayList<Student> al) {
        System.out.println("input id");
        Scanner sc = new Scanner(System.in);
        Student child = new Student();
        child.setId(sc.nextLine());
        System.out.println("Please enter the modified name");
        child.setName(sc.nextLine());
        int find = 0;
        for (int i = 0; i < al.size(); i++) {
            if (al.get(i).getId().equals(child.getId())) {
                find = 1;
                al.set(i, child);
                break;
            }
        }
        if (find == 0) {
            System.out.println("not found");
        } else {
            System.out.println("successful");
        }
        search(al);
    }
    public static void delete(ArrayList<Student> al) {
        System.out.println("input id");
        Scanner sc = new Scanner(System.in);
        String ipt = sc.nextLine();
        for (int i = 0; i < al.size(); i++) {
            if (al.get(i).getId().equals(ipt)) {
                System.out.println("successful");
                al.remove(i);
                return;
            }
        }
        System.out.println("not exsit");
        search(al);
    }
}

//Student.java
package package_test;
public class Student {
    private String id;
    private String name;
    public Student(String id, String name) {
        this.name = name;
        this.id = id;
    }
    public Student() {
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

public boolean equals(Object o) {
        if (this == o) return true;        //地址相同直接true
        if (o == null || getClass() != o.getClass()) return false;    //是否空或者不来自于同一个类
        Dog dog = (Dog) o;
        return weight == dog.weight;
    }
    @Override
    public int hashCode() {
        return weight;
    }
    @Override
    public String toString() {
        return "Dog{" +
                "weight=" + weight +
                '}';
    }

public class Test {
    public static void main(String[] args) {
        long start=System.currentTimeMillis();
        for(int i=0;i<100000;i++){}
        long end=System.currentTimeMillis();
        System.out.println("for循环十万次的运行时长:"+(end-start)+"毫秒");
    }
}

//装箱：基本数据类型转为包装类
        Integer a=Integer.valueOf(32);
        Integer a2=32;
//拆箱：包装类转为基本数据类型
        int b=a.intValue();
//数字转String
String s=String.valueOf(12);
//String转数字
int c=Integer.parseInt(s);
//String转Integer转数字
int c=Integer.valueOf(s).intValue();

Date date=new Date();
        date.setTime(234);
        System.out.println(date.getTime());    //输出234

public static void main(String[] args) throws ParseException {    //throws只是把异常抛出，延迟处理。用trycatch处理比较好
        //Date转String
        Date d=new Date();
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String str=sdf.format(d);
        System.out.println(str);
        //String转Date
        d=sdf.parse(str);
        System.out.println(d);
    }

import java.util.Scanner;
public class hello{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int i=sc.nextInt();        //nextLine()是带空格的一行字符串
        System.out.println(i);
    }
}
next() 不能得到带有空格的字符串，nextLine()可以。
//注意：nextInt接下来nextLine，字符串会直接读取输入的数字之后的空格、回车，例如输入23回车，结果a的值是回车。
//int b=sc.nextInt();String a=sc.nextLine();

//定义数组
int []a;
int b[];
int[][] x,y;//x和y都是二维数组
int[] z,t[];//z是一维数组，t是二维数组
//初始化，栈内存存储局部变量，使用后立即消失。new申请堆内存空间，使用后会在垃圾回收期空闲时回收
int d[]=new int[3];//动态初始化
int c[]={1,2,3};//或int c[]=new int[]{1,2,3};静态初始化
//直接输出数组会输出地址
System.out.println(a);    //[I@5b444398
//数组转字符串
System.out.println(Arrays.toString(c));    //[1, 2, 3]
//多数组指向相同堆内存，改动e内容后，c内容也会改变
int e[]=c;

public class hello {
    public static void main(String args[]) {
        f();
    }
    public static void f() {
        System.out.println("3f");
    }
    public static void f(int a) {        //重载，注意返回值同，参数不同
        System.out.println(a);
    }
//    下面两个注释的方法就不是重载，会报错
//    public static int f(){    //返回值不同
//        System.out.println("hello");
//    }
//    void f(){    //修饰符不同
//        return 666;
//    }
}

public class Phone {
    public Phone() {
        System.out.println("hhh");//创建对象时会直接运行构造方法
    }
}

public class Phone {
    int price;//成员变量在堆内存
    private int age;
    public void setAge(int a) {
        age = a;
    }
//或者用this
//    public void setAge(int age) {
//        this.age = age;
//    }
    public int getAge() {
        return age;
    }
}
//使用
public class hello {
    public static void main(String args[]) {
        Phone p = new Phone();
        p.setAge(12);
        System.out.println(p.getAge());
    }
}

public class Phone {
    static int price;//成员变量在堆内存
}
//使用
public class hello {
    public static void main(String args[]) {
        Phone.price=4;
        //fun();会报错，静态方法只能访问静态方法或变量。
    }
    public fun(){};
}

public abstract class Animal{
    abstract void m(); //抽象方法
abstract void n(); //抽象方法
}
 
class Dog extends Animal{    //非抽象子类
     //实现父类所有抽象方法
      void m(){
          .........
      }
      void n(){
          .........
      }
}
abstract class Cat extends Animal{}//抽象子类，不需要重写父抽象类的抽象方法

public class Phone {
    private int age;
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
}

public class Animal { 
    public String name;   
    int age=3; 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
//子类 
public class Penguin  extends  Animal{ 
    int age=4;
    public void show(){
        int age=5;
         System.out.println(age);   //5,子类可以访问父类非私有成员变量
        System.out.println(this.age);//4
        System.out.println(super.age);//3
    }
}

//定义类
public class Phone {
    int price;//对象在堆内存，成员变量便也在堆内存，创建对象时有初始值。
    public void fun() {
        int tmp;//局部变量在栈内存，不赋值就用会报错
        System.out.println("phone");
    }
}

//创建对象，建议先写new Phone()然后ctrl+alt+v补全声明
Phone p=new Phone();

public class Outer {
    int num=10;
//定义成员内部类：在成员位置定义类
    public class Inner{        //一般private，用外部类访问内部类更安全
        public void show(){
            System.out.println("innershow"+num);    //内部类可直接访问外部类成员。
        }
    }
//外部类访问成员内部类
    public void fun(){        
        Inner in=new Inner();
        in.show();
    }
//局部内部类：在成员方法内定义类
    public void fun2(){
        class Inner2{        //成员内部类不能public和private
            void show(){
                System.out.println("成员内部类");
            }
        }
        Inner2 in=new Inner2();
        in.show();
    }
//匿名内部类：在成员方法内定义子类，实现接口或继承抽象类
    public void fun3(){
        Phone p=new Phone() {            //自己写的Phone接口
            @Override
            public void show() {
                System.out.println("实现接口的匿名内部类");
            }
        };            //注意是一个语句有分号
        p.show();
    }
}
//内部类创建对象（一般内部类私有，使用外部类访问内部类）
public class Test {
    public static void main(String[] args) {
    Outer.Inner i=new Outer().new Inner();
    i.show();
    }
}

public class Phone {
    int price;//成员变量在堆内存
    private int age;
    public void setAge(int age) {
       this.age = age;
    }
    public int getAge() {
        return age;
    }
}

public class Animal { 
    public String name;   
    int age=3; 
    public Animal(String name, int age) { 
        //初始化属性值
    } 
    public void show() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
//子类 
public class Penguin  extends  Animal{ 
    int age=4;
    public Penguin(){
        super();    //不写也会默认运行
}
@Override        //注解重写，检查重写是否正确。例如修饰符（子类重写方法的访问权限要≥父类）、函数名错误。
    public void show(){    //重写父类中show(),如果去掉public会报错。想再用super.show();
        int age=5;
         System.out.println(age);   //5,子类可以访问父类非私有成员变量
        System.out.println(this.age);//4
        System.out.println(super.age);//3
    }
}

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

List<String> a=new ArrayList<String>();

Animal a=new Cat();

public static void main(String[] args) {
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }

public interface Phone {
     public static final int price=4;    //修饰符可省略
     public abstract void show();        //修饰符可省略
}
public class PhoneImpl implements Phone{
    public void show(){        //必须是public，否则报错
        System.out.println("hello");
    }
}

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

int[] arr = {1, 2, 3};
        try {
            System.out.println(arr[10]);
        } catch (Exception e) {        //ArrayIndexOutOfBoundsException 
            e.printStackTrace();
        }
        System.out.println("有异常处理后程序不会中断，此处也能输出");

public class Student {
    public void checkScore(int score) throws ScoreException{    //要加throws，声明此方法会抛出异常
        if(score>100||score<0)throw new ScoreException("wrong Score");
        else System.out.println("分属正常");
    }
}
public class Demo {
    public static void main(String[] args) {
        Student s=new Student();
        try{
            s.checkScore(111);
        }catch (ScoreException e){
            e.printStackTrace();
        }
        System.out.println("这里也能输出");
    }
}
public class ScoreException extends Exception {     //自定义异常类
    public ScoreException() {
    }
    public ScoreException(String wrong_score) {
        super(wrong_score);    //带参构造，异常时控制台输出指定字符串
    }
}

import java.util.ArrayList;
public class RunoobTest {
    public static void main(String[] args) {
        List<String> sites = new ArrayList<String>();
        sites.add("Google");        //增
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        sites.add("Ai");
        System.out.println(sites);        //[Google, Runoob, Taobao, Weibo]
        Collections.sort(sites);        //字母顺序排序
        Collections.sort(sites, new Comparator<String>() {        //比较器长度排序
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        });
        System.out.println(sites.get(1));  // 查，访问第二个元素Runoob
        System.out.println(sites.contains("Google"));   //查，是否包含
        sites.set(2, "Wiki"); // 改，第一个参数为索引位置，第二个为要修改的值
        sites.remove(3); // 删除第四个元素
        System.out.println(sites.size());//计算大小
        //迭代器
        Iterator<String> it=sites.iterator();
        while(it.hasNext()) System.out.println(it.next());
    }
}

List list=new ArrayList();
ArrayList list=new ArrayList();

List list=new LinkedList()；

ListIterator<String> it=sites.listIterator();
        while(it.hasNext()) System.out.println(it.next());

public static void main(String[] args) {
        LinkedList<String> link=new LinkedList<String>();
        link.addLast("hello");
        link.addLast("world");
        for(String s:link) System.out.println(s);
        System.out.println(link);
    }

import java.util.HashSet;
import java.util.LinkedList;
public class Test2 {
    public static void main(String[] args) {
        HashSet<String > h=new HashSet<String>();
        h.add("nihao");
        String s1=new String("nihao");
        h.add(s1);
        System.out.println(s1=="nihao");        //false
        for(String s:h) System.out.println(s);     //不含重复元素 
    }
}

import java.util.HashSet;
public class Test {
    public static void main(String[] args) {    //输出23
        Dog dog1=new Dog(23);
        Dog dog2=new Dog(23);
        HashSet<Dog> h=new HashSet<Dog>();
        h.add(dog1);h.add(dog2);
        for(Dog dog:h) System.out.println(dog.weight);   
    }
}

package package1;
public class Dog extends Animal{
     int weight=4;
     public Dog(){
//         System.out.println("doggouzaao");
     }
     public Dog(int weight){
         this.weight=weight;
     }
    @Override
    public void show() {
        name="dogname";
        System.out.println("dog");
    }
    @Override
    public boolean equals(Object o) {    //alt+insert生成equals()和hashCode()方法。这里其实只需要重写hashCode方法就能保证自动去重，equals方法用于元素间的比较
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Dog dog = (Dog) o;
        return weight == dog.weight;
    }
    @Override
    public int hashCode() {
        return weight;
    }
    @Override
    public String toString() {
        return "Dog{" +
                "weight=" + weight +
                '}';
    }
}

import java.util.TreeSet;
public class Test {
    public static void main(String[] args) {
        Dog dog1=new Dog(23);
        Dog dog2=new Dog(45);
        TreeSet<Dog> h=new TreeSet<Dog>();
        h.add(dog1);h.add(dog2);
        for(Dog dog:h) System.out.println(dog.weight);
    }
}

package package1;
public class Dog extends Animal implements Comparable<Dog>{        //要实现Comperable<>并重写compareTo()方法
     int weight=4;
     public Dog(){
     }
     public Dog(int weight){
         this.weight=weight;
     }
    @Override
    public int compareTo(Dog dog){    //实参是上一只狗，本狗与上狗做比较
         return 1;        //按存取顺序排序，本狗比上只狗大
         //return -1;存储逆序排序
         //return 0;视为相等，重复删除。
            //return this.weight-dog.weight;按年龄从小到大排序，后狗-前狗。
    }
}

TreeSet<Dog> h=new TreeSet<Dog>(new Comparator<Dog>() {
            public int compare(Dog a,Dog b){
                if(a.weight!=b.weight) return a.weight-b.weight;
                else return a.name.compareTo(b.name);
            }
        });

import java.util.ArrayList;
public class Test2 {
    public static void main(String[] args) {
        Collection a=new ArrayList();
        Collection<String> b=new ArrayList<String>();    //泛型
        a.add("he");
        a.add(3);
        b.add("he");
//        b.add(3);   直接写时这里会报错，因为通过泛型指定了类型为String
        for(Object o:a) System.out.println(o);
        for(Object o:b) System.out.println(o);
    }
}

package package2;
public class Generic<T> {
    private T t;
    public T getT() {
        return t;
    }
    public void setT(T t) {
        this.t = t;
    }
}

package package2;
//创建对象时再指定具体类型
public class Test2 {
    public static void main(String[] args) {
        Generic<Integer> g=new Generic<Integer>();    //创建对象时指定具体类型为Integer
        g.setT(32);
        System.out.println(g.getT());
        Generic<String> g2=new Generic<String>();    //创建对象时指定具体类型为String
        g2.setT("hello");
//        g2.setT(34);指定了String，运行时安全检测报错
        System.out.println(g2.getT());
    }
}

package package2;
public class Generic {
    public <T>void show(T t){
        System.out.println(t);
    }
}

List<?> l0=new ArrayList<Number>();

List<? extends Object> l1=new ArrayList<Number>();    //通配object的子类

List<? super Integer> l2=new ArrayList<Number>();    //通配Integer的父类

import java.util.*;
public class Test2 {
    public static void main(String[] args) {
        //声明
        Map<String, String> map = new HashMap<>();
        //添加
        map.put("aaa","bbb");map.put("cc","dd");map.put("e","f");
        //获取,如果"aaa"对应value不为null则返回value；如果为null，则返回null。
        System.out.println(map.get("aaa"));
        //获取,如果"aaa"对应value不为null则返回value；如果为null，则返回"default"字符串。
        System.out.println(map.getOrDefault("aaa", "default"));
        //获取所有keys
        Set<String> strings = map.keySet();
        //获取所有values
        Collection<String> values = map.values();
        //遍历map
        Set<Map.Entry<String,String>> set=map.entrySet();
        for(Map.Entry<String,String> i:set){
            System.out.println(i.getKey()+i.getValue());
        }
    }
}

import java.io.File;
import java.io.IOException;
public class Demo {
    public static void main(String[] args) throws IOException {
        File f=new File("D:\\1\\2.txt");
      //只创建已存在文件夹“D://1”下的2.txt。若“D://1”不存在，报错IOException: 系统找不到指定的路径。
        System.out.println(f.createNewFile());  //true，当目标位置已存在同名文件则创建失败输出false
    }
}

new File("1.txt");

File file = new File("D://1//1.txt");
        File file1 = new File("D:/1/2.txt");
        File file2 = new File("D:\\1\\3.txt");
//        File file3 = new File("D:\1\4.txt");  //这样会报错，单个反斜杠会进行转义
        System.out.println(file.createNewFile());   //true
        System.out.println(file1.createNewFile());   //true
        System.out.println(file2.createNewFile());   //true
//        System.out.println(file3.createNewFile());   //false

System.out.println(System.getProperty("user.dir"));    //D:\workspace\java\test

File f=new File("1\\2\\3");
        System.out.println(f.mkdirs());
        File f1=new File("1\\2\\3\\4.txt");
        System.out.println(f1.createNewFile());
        File[] f2=f.listFiles();        //listFiles()是路径下的所有文件组成的数组，若f文件会报错
        for(File file:f2){
            if(file.isFile()) System.out.println(file.getName()+","+file.getPath());
        }
//删除
//删除目录时要确保目录下没文件。
        f1.delete();f.delete();

FileOutputStream fos=new FileOutputStream("1.txt");
        byte b[]="abcde".getBytes();
        fos.write(b);
        fos.close();

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo {
    public static void main(String[] args)  {
        FileOutputStream fos=null;
        try {
             fos=new FileOutputStream("z://1.txt");
            byte b[]="efe".getBytes();
            fos.write(b);
            fos.close();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            System.out.println("finally");
            if(fos!=null){        //防止空指针异常
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileInputStream fis=new FileInputStream("1.txt");
        byte b[]=new byte[1024];    //一般是1024整数倍
        int len=-1;
        while ((len= fis.read())!=-1) System.out.println(new String(b,0,len));
        fis.close();

FileInputStream fis=new FileInputStream("D://1.png");
        FileOutputStream fos=new FileOutputStream("D://1//1.png");
        byte []b=new byte[1024];
        int len=fis.read(b);
        while(len!=-1){
            System.out.println(len);
            fos.write(b,0,len);len=fis.read(b);
        }

<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.6</version>
</dependency>

//fis:输入流
//os:输出流
IOUtils.copy(fis,os);

package com.heima.stream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo10_Chinese {
    public static void main(String[] args) throws IOException {
        //demo1();
        FileOutputStream fos = new FileOutputStream("zzz.txt");
        fos.write("我读书少,你不要骗我".getBytes());
        fos.write("\r\n".getBytes());
        fos.close();
    }
    public static void demo1() throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("yyy.txt");
        byte[] arr = new byte[4];
        int len;
        while((len = fis.read(arr)) != -1) {
            System.out.println(new String(arr,0,len));
        }
        fis.close();
    }
}

OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("1.txt"),"utf-8");
        osw.write("你好hello");
        osw.close();   //close很重要
        InputStreamReader isr=new InputStreamReader(new FileInputStream("1.txt"),"utf-8");
        int ch;
        while ((ch=isr.read())!=-1){
            System.out.println((char) ch);
        }
//        char []c=new char[1024];int len;
//        while ((len=isr.read(c))!=-1){
//            System.out.println(new String(c,0,len));
//        }
        isr.close();

//文本复制
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
public class Demo {
    public static void main(String[] args) throws IOException {
        BufferedWriter bw=new BufferedWriter(new FileWriter("1//copy.txt"));
        BufferedReader br=new BufferedReader(new FileReader("1.txt"));
        char[] c=new char[1024];
        int len;
        while((len=br.read(c))!=-1){
            bw.write(c,0,len);bw.flush();
        }
        bw.close();br.close();
    }
}

BufferedWriter bw=new BufferedWriter(new FileWriter("1//copy.txt"));
        BufferedReader br=new BufferedReader(new FileReader("1.txt"));
        String line;
        while ((line=br.readLine())!=null){
            bw.write(line);bw.newLine();bw.flush();
        }
        bw.close();br.close();

//文本复制JDK7异常处理
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
public class Demo {
    public static void main(String[] args){
        try(BufferedWriter bw=new BufferedWriter(new FileWriter("1\\2\\copy.txt"));
            BufferedReader br=new BufferedReader(new FileReader("1.txt"));){
            char[] c=new char[1024];
            int len;
            while((len=br.read(c))!=-1){
                bw.write(c,0,len);
            }
//            bw.close();br.close();不用close了，JDK7自动释放资源
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

PrintStream ps=System.out;
        ps.println("hello");

PrintStream pw=new PrintStream("1.txt");
pw.println("hello");
pw.println(23);
pw.close();

PrintWriter pw=new PrintWriter("1.txt",true);//自动刷新true
pw.println("hello");        //直接写一行加刷新
pw.println(23);

Properties prop=new Properties();
        prop.setProperty("a","b");prop.setProperty("c","d");
        BufferedWriter bw=new BufferedWriter(new FileWriter("1.txt"));
        prop.store(bw,"hello");
        bw.close();
        Properties p2=new Properties();
        BufferedReader br = new BufferedReader(new FileReader("1.txt"));
        p2.load(br);
        Set<String> s=p2.stringPropertyNames();
        for(String key:s){
            System.out.println(key+p2.getProperty(key));

public class Demo {
    public static void main(String[] args){
        MyThread a=new MyThread("a"),b=new MyThread("b");
        a.start();b.start();
    }
}
public class MyThread extends Thread{
    @Override
    public void run(){
        for(int i=0;i<100;i++) System.out.println(getName()+":"+i);
    }
    public MyThread() {
    }
    public MyThread(String name) {
        super(name);
    }
}

Thread.currentThread().setName("主线程");
        System.out.println(Thread.currentThread().getName());

public class Demo {
    public static void main(String[] args){
        MyRunnable mr=new MyRunnable();
        Thread a=new Thread(mr,"a"),b=new Thread(mr,"b"),c=new Thread(mr);
        a.start();b.start();c.start();
    }
}
public class MyRunnable implements Runnable{
    @Override
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

package train;
public class Demo {
    public static void main(String[] args) {
        new Thread(()->{
            System.out.println("hello");
        }).start();
        new Thread(()->{
            Thread.currentThread().setName("a");
            for(int i=0;i<100;i++) System.out.println(Thread.currentThread().getName()+":"+i);
        }).start();
        new Thread(()->{
            Thread.currentThread().setName("b");
            for(int i=0;i<100;i++) System.out.println(Thread.currentThread().getName()+":"+i);
        }).start();
    }
}

synchronized(同步对象) {
        //多条语句操作共享数据的代码 
    }

InetAddress administrator = InetAddress.getByName("diannaomingcheng");
        System.out.println(administrator.getHostAddress());
        System.out.println(administrator.getHostName());

package udp_package;
//发送数据
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.nio.charset.StandardCharsets;
public class SendDemo {
    public static void main(String[] args) throws IOException {
        InetAddress ia = InetAddress.getByName("zhujiming");
        DatagramSocket ds=new DatagramSocket();
        byte []b="hello世界".getBytes();
        DatagramPacket dp=new DatagramPacket(b,b.length,ia,1234);
        ds.send(dp);
        ds.close();
    }
}

package udp_package;
//接受数据
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        DatagramSocket ds=new DatagramSocket(1234);
        byte []b=new byte[1024];
        DatagramPacket dp=new DatagramPacket(b,1024);
        ds.receive(dp);
        System.out.println("接受到的数据："+new String(dp.getData(),0,dp.getLength()));
    }
}

package tcp_package;
//客户端发送数据
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
public class SendDemo {
    public static void main(String[] args) throws IOException {
        InetAddress ia=InetAddress.getByName("mingzi");
        Socket s=new Socket(ia,1234);
        OutputStream os=s.getOutputStream();    //这里就是IO流了，可以把字节输出流OutputStream转为缓冲字符输出流BufferedWriter，从而发送字符
        os.write("hello世界".getBytes());
        s.close();
    }
}

package tcp_package;
//服务端接受数据
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        ServerSocket ss=new ServerSocket(1234);
        Socket s=ss.accept();
        InputStream is=s.getInputStream();
        byte[] b=new byte[1024];
        int len=is.read(b);
        System.out.println("data is:"+new String(b,0,len));
        ss.close();        //关ss就行了，因为s是从ss得到的。
    }
}

package tcp_package;
import java.io.*;
import java.net.Socket;
public class ClientDemo{
    public static void main(String[] args) throws IOException {
        Socket s=new Socket("xx.xx.xx.xx",1234);
        BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        String line;
        while ((line=br.readLine())!=null){
            if(line.equals("886")) break;
            bw.write(line);
            bw.newLine();
            bw.flush();        //缓冲流别忘了刷新，不然发不出去
        }
        s.shutdowmOutput();
//shutdowmOutput（）代表停止发送数据，此处可加BufferedReader反馈代码，接收服务端传输成功的反馈
        s.close();        //s是bw的源头，关s就关了bw
        br.close();        
    }
}

package tcp_package;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        ServerSocket ss=new ServerSocket(1234);
        Socket s=ss.accept();
        BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));
        String line;
        while((line=br.readLine())!=null){
            System.out.println(line);
        }
        ss.close();
    }
}

(形参)->{方法内的代码块}

public class Demo {
    public static void main(String[] args) {
        fun((a,b)->{    //Lambda形参类型、返回类型可以省略
            return a+b;
        });
    }
    public static void fun(Dog d){
        d.add(1,4);
    }
}
public interface Dog {    //单方法接口
    public int add(int a,int b);//只能有一个方法
}

public class Test {
    public static void main(String[] args) {
//Lambda表达式简化单方法接口实现类对象的创建过程
        fun((a,b)->{
            return a+b;
        });
//如果不用Lambda表达式，则要用下面的方式调用fun(Dog d)方法
        fun(new Dog() {
            @Override
            public int add(int a, int b) {
                return a+b;
            }
        });
    }
    public static void fun(Dog d){
        d.add(1,4);
    }
}

new Thread(()->{    //虚拟机根据上下文能推断出实现的接口是Runnable
            Thread.currentThread().setName("a");
            for(int i=0;i<100;i++) System.out.println(Thread.currentThread().getName()+":"+i);
        }).start();

public interface Dog {
    public default void eat(){
        System.out.println("he");
    }
}

public interface Dog {
    public static void eat(){
        System.out.println("he");
    }
}
public class Demo {
    public static void main(String[] args) {
        Dog.eat();
    }
}

public interface Dog {
    public static void eat(){    //静态方法只能访问静态变量和方法
        look();
    }
    public default void sleep(){        //非静态方法可以访问静态非静态成员
        look();
    }
    private static void look(){    //私有成员仅本类内可见
        System.out.println("look");
    }
}

引用类::不带括号的方法名

public class Demo {
    public static void main(String[] args) {
        fun((s)-> System.out.println(s));    //fruit
        fun(System.out::println);    //fruit        //根据上下文推导出标准输出流类的println方法
    }
    public static void fun(Dog dog){    //Dog是个接口
        dog.eat(" fruit");
    }
}

fun((s)->Integer.parseInt(s));    //字符串转数字，
        fun(Integer::parseInt);        //根据上下文推导Integer类的parseInt方法

fun(new Dog() {
            @Override
            public void eat(String s) {
                System.out.println(s);
            }
        });
        fun(System.out::println);

public class Demo {
    public static void main(String[] args) {
        Dog dog=new Dog();        //Dog是类        
        fun(dog::eat);        引用对象的方法，实参为对象，形参是接口
    }
    public static void fun(Cat c){        //Cat是接口
        c.look("4346");
    }
}

public class Test {
    public static void main(String[] args) {
        // 定义一个int数组
        int[] arr = {19, 50, 28, 37, 46};
        // 调用getMax方法，方法的形参是函数式接口（单方法接口），
        // 实参Lambda表达式（接口方法的逻辑，相当于创建了一个Supplier对象）
        // 返回值是Lambda表达式的返回值，sup.get()
        int maxValue = getMax(() -> {
            int max = arr[0];
            for (int i = 1; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        });
        System.out.println(maxValue);
    }
    /**
     * 返回一个int数组中的最大值
     * @param sup 生产者，是个函数式接口，实参是Lambda表达式（接口方法的逻辑，相当于一个Supplier对象）
     * @return int 最大值
     */
    private static int getMax(Supplier<Integer> sup) {
        return sup.get();
    }
}

public class Demo {
    public static void main(String[] args) {
        boolean b = fun("hello", s -> s.length() > 5, s -> s.length() <100);
    }
    private static boolean fun(String s, Predicate<String> p1, Predicate<String> p2) {
        return p1.and(p2).test(s);
    }
    private static boolean fun(String s, Predicate<String> p) {
        return p.negate().test(s);
    }
}