2020.8.10课堂笔记(Java高级API总结)

1、集合框架
List:有序
ArrayList:长度可变的数组，便于查找和随机访问
LinkedList（Node）:双向链表，便于插入和删除（针对Node的next和pre）
Set:不重复
HashSet：HashMap的key的hashCode()和equals()方法共同保证不重复
addAll() 对Set和List进行互相转换
Map:Entry<k,v>键值对 Entry是Map的一个静态类
遍历：List：fori,增强for,迭代器while hasnext
Set:增强for，迭代器
Map： entrySet() KeySet() values()
泛型：限定了集合类型的输入和输出 Comparable
add()/put()/addAll()
remove()
set()/put()
ger() HashSet没有get方法，原因是没有下标/List是get下标，Map是遍历key
Collections： ComparAble
new Comparator{int compare(Student o1,Student o2){return o1.stuId-o2.stuId}}比较两个相同类型,升序
2、实用类
包装类：方便泛型使用，与String类型的转换
装箱：把基本数据类型变为包装类型
拆箱：把包装类型转为基本数据类型
Integer a=1;//自动装箱
int b=new Integer(12);//自动拆箱，一般用在方法的返回值，参数列表传递的时候
Math类：数学公式
Random类：各种随机数，种子，一旦加了种子就是伪随机
枚举类：特殊的类，私有构造，直接写的值都是当前类型的一个个对象
String：底层是字符数组常量，不可改变
indexof，split，charAt，substring截取字符串 直接传一个参数，从头截取到哪里，两个参数，从第一个参数的下标，到第二个参数的下标，左闭右开
toCharArray 转成char数组，适用于有中文的情况 getBytes 转成byte数组
StringBuffer：线程安全的，比较慢
append(),toString()
StringBuilder单线程的，较快，长度可变的字符数组，底层是变量，初始16个，再扩容
Date：System.currentTimeMillis() 默认显示的UTC时间
SimpleDateFormat时间格式："yyyy-MM-dd HH:mm:ss.S"一般不用毫秒数(.S)
3、io流:InputStream OutputStream Reader Writer
普通流：FileInputStream FileOutputStream FileReader FileWriter
转换流：InputStreamReader OutputStreamWriter，转换流及字符编码
高级流：
缓冲流：
一行一行读，整个字符串写，只能装Reader和Writer，把流在闲时先一步读取进缓存
BufferedReader、BufferedWriter
二进制流：
先把要传输的图片、视频、音频等先放入文件流，
再把文件流装入DataInputStream、DataOutputStream
相对安全
对象流：
对象要先实现Serializable接口，ObjectInputStream和ObjectOutputStream
读取过程：
1、把文件放入文件输入流中，先定义再处理异常的方式
2、read() read(b) …read范围Byte数组 （放入字符串）
3、关闭流
写入过程：
与读取过程基本类似，把输出路径装入流，把字符串写进去
4、多线程
继承Thread类，实现Runnable接口
start()和run()的区别：start是真正实现多线程的方法，run是普通方法 start调用start(0)然后调用run(方法)
实现Callable接口：call()方法有返回值(泛型)和run()方法区别并不大
FutureTask task=new FutureTask(Callable接口的实现类的对象);
Thread t=new Thread(task);
t.start();
task.get();//可以获取到它的返回值
5、反射：运行时获取对象、操作对象及其属性和方法
类型.class、对象.getClass()、Class.forName(“类的全路径”);
获取构造方法(getDeclaredConstructor()) newInstance()
方法(getDeclaredMethod(“方法名”,参数类型)) invoke(对应的参数)
属性 (getDeclaredField(“属性名”)) set()
权限不够的需要执行setAccessible(true);
6、xml和json
xml格式：<?xml version="1.0" charset="UTF-8"?>
根标签、一一对应(有开头、有结束)
作用：传输数据(基本被抛弃了)、配置文件
DOM获取：
1、DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
2、DocumentBuilder builder = factory.newDocumentBuilder();
3、Document document=builder.parse(“xml路径/或者用InputStream的形式获取”);
4、Element e=document.getElementById/document.getElementsByName(“标签名称”);
5、e.item(0);
Dom保存：
1、TransformFactory tf=TransformFactory.newInstance();
2、Transform t=f.newTransform();
3、DomSource s=new DomSource(document);
4、StreamResult sr=new StreamResult(writer对象装入目标地址);
5、tf.transform(s,sr);
json:对象要实现Serializable接口
对象转json格式字符串： JSON.toJSONString(对象);
对象转json JSON.toJSON/JSON.parseObject(json串);
json转对象 JSON.toJavaObject(json对象,java对象类型.class);
7、正则表达式：规则表达式
匹配规则

File f=new File();
int start;
int end;
HashMap map;
在new Thread线程的时候传递进来start end
run(){
FileInputStream fis=new FileInputStream(f);
readOne(byte[],0,10000);

}
readOne(byte[],10001,20000);

两个Map 比对能找得到次数+1  消费金额 去小留大

Customer：

package homework;

/**
 * @Author: ChaoKeAiMuZhi
 * @Date: 2020/8/4 18:26
 * @Description:
 **/
public class Customer implements Comparable<Customer>{
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    private String name;
    private double money;


    public Customer() {
    }


    public Customer(String name, double money) {
        this.name = name;
        this.money = money;

    }

    /*@Override
    public String toString() {
        return "顾客姓名"+name+"，消费金额"+money+"。\r\n";
    }
*/


    @Override
    public int compareTo(Customer o) {
        if(o.getName().equals(name)) return 0;
        return -1;
    }
}

Test2：

package homework;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @Author: ChaoKeAiMuZhi
 * @Date: 2020/8/5 9:08
 * @Description:
 **/
public class Test2{
    public static void main(String[] args) {
        long l = System.currentTimeMillis();
        /*ArrayList arr = readMethod();
        Customer[] customers=new Customer[arr.size()];
        for (int i = 0; i < arr.size(); i++) {
            customers[i]=new Customer();
            String str=arr.get(i).toString();
            String[] split = str.split("：");
            if(split.length==1)break;
            customers[i].setName(split[0]);
            customers[i].setMoney(Double.parseDouble(split[1]));
        }*/

        Customer maxCus = new Customer();
        ArrayList<Customer> customers = readMethod();
        HashSet<String> set = new HashSet<>();
        int max = 0;
        int i = 0;
        for (; i < customers.size(); i++) {
            int count = 0;
            double money = customers.get(i).getMoney();
            if (set.contains(customers.get(i).getName())) continue;
            for (int j = i; j < customers.size(); j++) {
                if ((customers.get(i)).compareTo(customers.get(j)) == 0) {
                    count++;
                    if ((customers.get(j)).getMoney() > money) {
                        money = (customers.get(j)).getMoney();
                    }
                }
            }
            set.add(customers.get(i).getName());
            if (count > max) {
                maxCus.setName(customers.get(i).getName());
                maxCus.setMoney(money);
                max = count;
            }
           /* if(count==max && !customers.get(i).getName().equals(customers.get(max).getName())) maxNum.add(i);
        }*/
        }
        System.out.println("出现次数最多的姓名是："+maxCus.getName());
        System.out.println("出现次数" + max);
        System.out.println("消费金额是："+ maxCus.getMoney());
        System.out.println("计算时间："+(System.currentTimeMillis()-l));
        /*int max=str.split(customers[0].getName()).length;
        String tmp=customers[0].getName();
        for (int i = 0; i < customers.length; i++) {
            if(max<str.split(customers[i].getName()).length){
                max=str.split(customers[i].getName()).length;
                tmp=customers[i].getName();
            }
        }
        System.out.println("出现次数最多的姓名是"+tmp);
        double money=0;
        for (int i = 0; i < customers.length; i++) {
            if(customers[i].getName().equals(tmp) && customers[i].getMoney()>money){
                money=customers[i].getMoney();
            }
        }
        System.out.println("该用户消费金额最高为"+money);*/
    }

    public static ArrayList<Customer> readMethod() {
        FileReader fr = null;
        BufferedReader br = null;
        ArrayList<Customer> arr = new ArrayList<>();
        try {
            fr = new FileReader("src/homework/buy_record.txt");
            br = new BufferedReader(fr);
            String str;
            while ((str = br.readLine()) != null) {
                String[] split = str.split("：");
                Customer customer = new Customer(split[0], Double.parseDouble(split[1]));
                arr.add(customer);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return arr;
    }
}