面向对象核心

1.wrapper类

  包装类wrapper:每一个基本类型都有与之对应的对象(包装类型)
      面向对象编程：操作对象一定比操作基本类型要简单-提供了强大的功能为我们使用
      byte    Byte
      short   Short
      int     Integer
      long    Long
      float   Float
      double  Double
      char    Character
      boolean Boolean

   1.转换关系--- 不需要我们做，但要知道
      ① 基本类型->包装类         Integer.valueOf(int i);
      ② 包装类->基本类型         x.intValue();
      ③ 基本类型->String        String.valueOf(int i);
      ④!!!String->基本类型      Integer.parseInt(String s);
      ⑤String->包装类           Integer.valueOf(String s);
      ⑥包装类->String           x.toString();
      直接写出来的数字默认为int，直接写出来的小数默认double，直接量
   2.自动装箱和拆箱(autoboxing)

package com.hqyj.lls.wrapper;

public class TestWrapper {
    //主方法：程序的入口->读代码的入口，看代码从main的第一行开始看起
    public static void main(String[] args) {
        //① 基本类型->包装类
        int i = 100;
        Integer integer = Integer.valueOf(i);
        System.out.println(integer);

        // ② 包装类->基本类型
        Integer integer1 = 100;
        int i1 = integer1.intValue();
        System.out.println(i1);

        //③ 基本类型->String
        String s = String.valueOf(i);
        System.out.println(s);

        //!!!④String->基本类型
        //问：传入的参数String不匹配int会怎么样? NumberFormatException数字解析异常
//        String s1 = "123df";
        String s1 = "123";
        int i2 = Integer.parseInt(s1);
        System.out.println(i2);

        //⑤String->包装类  valueOf()
        String s2 = "111";
        Integer integer2 = Integer.valueOf(s2);
        String str = "21.0";
        Double d1 = Double.valueOf(str);
        System.out.println(d1);
        System.out.println(integer2);

        //⑥包装类->String  toString()
        Integer x = 100;
        String s3 = x.toString();
        System.out.println(s3);

        //autoboxing:基本类型和包装类之间的转换是自动完成的
        Integer a = 100;//Integer.valueOf(100);自动装箱
        Integer b = 200;//Integer.valueOf(100);//自动拆箱
        
        Integer c = a + b;
        System.out.println(c);
    }
}

集合: 存储数据的容器(数据结构)

Collection:是一个接口，定义了操作集合相关方法

Collection下有两个子接口 List Set

  1.1 常用方法
      ①add 添加元素
      ②addAll(Collection c);
      ③添加一个集合contains(Object o) 是否包含某个元素
      ④containsAll(Collection c) 是否包含某个集合
      ⑤size(); 判断集合的大小
      ⑥isEmpty();判断集合是否为空
      ⑦remove(Object);删除集合某个元素
      ⑧removeAll(Collection c);删除一个集合
      ⑨clear();清空集合

package com.hqyj.lls.collection;


import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;


public class TestCollectionMethod {
    public static void main(String[] args) {
        //测试Collection中常用方法
        //创建Collection对象  多态 向上转型
        
        Collection c1 = new ArrayList();
        //add 添加元素
        c1.add("hello");
        c1.add("world");
        c1.add("c");

        System.out.println(c1);//[hello, world]重写toString方法

        //contains(Object o) 是否包含某个元素
        System.out.println(c1.contains("hello"));

        //containsAll(Collection c) 是否包含某个集合
        ArrayList c2 = new ArrayList<>();
        c2.add("hello");
        c2.add("world");
        System.out.println("当前集合为：" + c2);
        System.out.println(c1.containsAll(c2));

        //size(); 判断集合的大小
        System.out.println(c1.size());

        //isEmpty();判断集合是否为空
        System.out.println(c1.isEmpty());

        //remove(Object);删除集合某个元素
//        System.out.println(c1.remove("hello"));
        System.out.println(c1);
        //addAll(Collection c); 添加一个集合
        ArrayList c3 = new ArrayList<>();
        c3.add("hb");
        c3.add("gg");
        System.out.println(c1.addAll(c3));
        System.out.println(c1);

        //removeAll(Collection c);删除一个集合
        System.out.println(c1.removeAll(c2));
        System.out.println(c1);

        //retainAll();保留当前集合元素，删除其他元素
        c1.retainAll(c2);
        System.out.println(c1);

        //clear();清空集合
//        c1.clear();
        System.out.println(c1);

        //toArray();  toArray(T[] t):参数为转换后数组的指定类型
        //常用
//        String[] s1 = c2.toArray(new String[c1.size()]);
        String[] s1 = c2.toArray(new String[]{});
        System.out.println(Arrays.toString(s1));

        //重点
        Object[] objects = c2.toArray();
        //怎么把Object类型数组转为String[]
     
        //思路：先取出所有的Object对象，一一转为String类型在存储到String类型的数组中
        String[] str = new String[objects.length];
        for (int i = 0; i < objects.length; i++) {
            str[i] = (String) objects[i];
        }
        System.out.println(Arrays.toString(str));
    }
}

1.2 练习

创建学生对象，存入5个数据到集合，输出在控制台，并将集合转换为数组输出

package com.hqyj.lls.homework;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;


public class Person {
    private String username;
    private String password;


    @Override
    public String toString() {
        return "姓名：'" + username + ''' +
                ", 密码='" + password + '''
                ;
    }



    public Person(String username, String password) {
        this.username = username;
        this.password = password;


    }

    public static void main(String[] args) {
        //创建Person对象
      Person p1 = new Person("张三","111");
      Person p2 = new Person("李四","222");
      Person p3 = new Person("王五","333");
      Person p4 = new Person("韩梅梅","444");
      Person p5 = new Person("陈久","555");

      //创建集合对象
        Collection c = new ArrayList();
        //存储信息
        c.add(p1);
        c.add(p2);
        c.add(p3);
        c.add(p4);
        c.add(p5);
       //打印集合
        for (Person p : c) {
            System.out.println(p);
          }
        System.out.println("--------");
        //转换为Person数组
        //方法1
        Person[] people = c.toArray(new Person[]{});
        System.out.println(Arrays.toString(people));
        System.out.println("--------");
        //方法2
        Object[] objects = c.toArray();
        Person[] str = new Person[objects.length];
        for (int i = 0; i < objects.length; i++){
            str[i] = (Person)objects[i];
        }
        System.out.println(Arrays.toString(str));


    }

}

     List: 有序(自然顺序，元素存入的先后顺序，非排序) 可重复的集合

 1.1！！ArrayList
         ①底层 Object类型数组
         ②线程非安全
         ③默认初始化容量：10
         ④扩容算法：1.5倍
         ⑤subList：截取子串，但和原串共用一个资源
         ⑥做查询快

1.2 LinkedList
         ①底层是链表实现，内部封装一个静态内部类Node
         ②做修改的时候块，应为是指针实现的

ArrayList和LinkedList的区别：

1、数据结构不同

    ArrayList是Array(动态数组)的数据结构，LinkedList是Link(链表)的数据结构。

2、效率不同

     当随机访问List（get和set操作）时，ArrayList比LinkedList的效率更高，因为LinkedList是线性的数据存储方式，所以需要移动指针从前往后依次查找。 当对数据进行增加和删除的操作(add和remove操作)时，LinkedList比ArrayList的效率更高，因为 ArrayList是数组，所以在其中进行增删操作时，会对操作点之后所有数据的下标索引造成影响，需要进行数 据的移动。

3、自由性不同

      ArrayList自由性较低，因为它需要手动的设置固定大小的容量，但是它的使用比较方便，只需要创建，然后 添加数据，通过调用下标进行使用；而LinkedList自由性较高，能够动态的随数据量的变化而变化，但是它 不便于使用。

4、主要控件开销不同

      ArrayList主要控件开销在于需要在lList列表预留一定空间；而LinkList主要控件开销在于需要存储结点 信息以及结点指针信息。

package com.hqyj.lls.list;

import java.util.ArrayList;
import java.util.List;


public class TestArrayList {
    public static void main(String[] args) {
        

        //1.初始化过程  ArrayList()   ArrayList(int i)
        ArrayList l1 = new ArrayList<>();//初始化了一个无长度的空数组
        System.out.println(l1.size());
        ArrayList l2 = new ArrayList<>(15);//初始化指定长度额数组
        System.out.println(l2.size());

        
        l1.add("java");
        l1.add("c");
        l1.add("c++");
        l1.add("php");
        l1.add("python");

        //3.SubList:截取子串 子串和原串共用一块资源
        List s = l1.subList(1, 4);//前包后不包
        System.out.println(s);
        //问题：对子串元素值修改，查看原串有无变化
        for (int i = 0; i < s.size(); i++) {
            s.set(i,s.get(i) + "1");
        }
        System.out.println(s);
        System.out.println(l1);


    }
}

1.3 Vector
          和ArrayList实现原理相同，但线程安全，运行效率低，不常用 

1.4.Stack

package com.hqyj.lls.list;

import java.util.Stack;


public class TestStack {
    public static void main(String[] args) {
        Stack s = new Stack<>();
        s.push(1);
        s.push(2);
        s.push(3);
        s.push(4);
        System.out.println(s);//[1, 2, 3, 4]
        System.out.println(s.pop());//4
        System.out.println(s);
        System.out.println(s.peek());
        System.out.println(s);
        System.out.println(s.empty());
        System.out.println(s.search(1));//返回 1 这个元素的索引
    }
}

 概述

Set:无序 无重复的集合

Set的常见实现类:

HashSet：底层使用HashMap操作数据

TreeSet：底层封装了TreeMap，对元素可以进行排序，树结构实现

LinkedHashSet:具有自然顺序的操作
    

package com.hqyj.lls.set;

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;


public class TestSet {
    public static void main(String[] args) {
        //1.测试Set的特征 无序无重复
        HashSet set = new HashSet<>();
        set.add("java");
        set.add("c");
        set.add("php");
        set.add("c++");
        set.add("python");
        set.add("python");
        set.add("python");
        System.out.println(set);

        //2.测试LinkedHashSet  有序
        LinkedHashSet linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("java");
        linkedHashSet.add("c");
        linkedHashSet.add("c++");
        linkedHashSet.add("python");
        linkedHashSet.add("java");
        System.out.println(linkedHashSet);

        //3.TreeSet
        TreeSet treeSet = new TreeSet<>();
        for (int i = 0; i <10 ; i++) {
            treeSet.add((int)(Math.random()*100));
        }
        System.out.println(treeSet);
    }
}

   集合排序问题
      1.集合的排序规则
         ①如果要对对象进行排序，则对象必须实现Comparable
         ②重写compareTo方法设置排序的规则
         ③根据返回值确定大于小于或等于，所对应返回值整数：正整数，零，负整数
      2.集合的临时排序规则
        在sort方法第二个参数中采用匿名内部类的形式改写排序规则

package com.hqyj.lls.list;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;


public class TestComparable {
    public static void main(String[] args) {
        //1.测试Integer的排序
        ArrayList list = new ArrayList<>();
        for (int i = 0; i < 7; i++) {
            list.add((int) (Math.random() * 100));
        }
        System.out.println("原集合：" + list);
        Collections.sort(list);
        //问题：他是依据什么排序的?我们怎么改变它的规则?
        System.out.println("排序后：" + list);

        //2.测试对Person的salary排序
        ArrayList people = new ArrayList<>();
        people.add(new Person("张三", 2000.3));
        people.add(new Person("李四", 34345.9));
        people.add(new Person("王五", 434.88));
        people.add(new Person("韩梅梅", 3456.7));
        System.out.println("排序前：" + people);
        Collections.sort(people);
        System.out.println("排序后" + people);

        //测试临时排序规则
       
        Collections.sort(people, (o1, o2) -> o1.getSalary() < o2.getSalary() ? 1 : (o1.getSalary().equals(o2.getSalary()) ? 0 : -1));
        System.out.println("排序后" + people);

    }
}

5.1   队列Queue:

实现类常用LinkedList
       先进先出

package com.hqyj.lls.queue;

import java.util.LinkedList;
import java.util.Queue;


public class TestQueue {
    public static void main(String[] args) {
        //1.Queue
        Queue queue = new LinkedList<>();
        //offer();入队
        queue.offer("a");
        queue.offer("c");
        queue.offer("v");
        queue.offer("g");
        System.out.println(queue);//[a, c, v, g]

        //poll();出队
        System.out.println(queue.poll());//a
        System.out.println(queue);//[c, v, g]

        //peek();取出第一个数据
        System.out.println(queue.peek());
    }
}

5.2 双端队列:
 

package com.hqyj.lls.queue;

import java.util.Deque;
import java.util.LinkedList;


public class TestDeque {
    public static void main(String[] args) {
        Deque deque = new LinkedList<>();
        //1.测试双端队列进出
        deque.offerFirst("a");
        deque.offerFirst("b");
        deque.offerFirst("c");
        deque.offerLast("d");
        deque.offerLast("e");
        deque.offerLast("f");
        System.out.println(deque);//[c, b, a, d, e, f]
        System.out.println(deque.pollFirst());//c
        System.out.println(deque.pollLast());//f
        System.out.println(deque.peekLast());//e
        //测试 双端队列如果限定只能从一端进同一端出，和栈无区别

    }
}

6.1 迭代器：专门用来遍历集合的
    遍历集合的4种方式：①基本for   ②增强for ③forEach方法 ④ 迭代器

package com.hqyj.lls.iterator;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.function.Consumer;


public class TestIterator {
    public static void main(String[] args) {
        ArrayList l1 = new ArrayList<>();
        for (int i = 0; i < 7; i++) {
            l1.add((int)(Math.random()*100));
        }
        //1.基本for循环
        System.out.println("----基本for----");
        for (int i = 0; i < l1.size(); i++) {
            System.out.println(l1.get(i));
        }

        //增强for循环
        System.out.println("----增强for----");
        for (Integer i: l1) {
            System.out.println(i);
        }

        int[] i = new int[]{2,3,4};
        for (int o : i) {
            System.out.println(o);
        }


        //forEach方法
        System.out.println("----foreach方法----");
        l1.forEach(integer -> System.out.println(integer));

        //迭代器
        System.out.println("----迭代器----");
        //获取迭代器对象
        Iterator it = l1.iterator();
        while (it.hasNext()){//判断是否有下一个元素   尾插法
            //判断删除大于50的所有元素
            //ConcurrentModificationException 用迭代器遍历出的元素，必须用迭代器的remove方法删除，二不能使用集合的方法
            if (it.next() > 50){
//                l1.remove(it.next());
                it.remove();
            }
        }
        System.out.println(l1);
    }
}

6.2 面试题(*****):
        增强for循环原理是迭代器，二迭代器是专门用来遍历集合的，但数组不是集合，为什么增强for循环可以遍历数组？
           反编译: 使用增强for循环遍历数组，会解析成一般for循环，但遍历集合时，会解析为迭代器

6.3 练习 

 1.控制台输入一个字符串，对字符串去重
 2.有10个学生，每个学生有1个分数，使用集合统计：
                1.学生总分
                2.学生平均分
                3.学生最高分
                4.学生按分数从高到低依次排序
                5.做临时排序从低到高

package com.hqyj.lls.homework;

import java.util.*;

public class Zy02 {
    public static void main(String[] args) {
//       getChar();
       getNum();
    }
    public static void getChar(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s = sc.nextLine();
        char[] ch = s.toCharArray();
        HashSet set = new HashSet<>();
        for (int i = 0; i < ch.length; i++) {
            set.add(ch[i]);
        }
        System.out.println("去重后的字符串：" + set);
    }
    public static void getNum(){
        ArrayList list = new ArrayList<>();
        list.add(new Student("a",90));
        list.add(new Student("b",65));
        list.add(new Student("c",78));
        list.add(new Student("d",89));
        list.add(new Student("e",84));
        list.add(new Student("f",96));
        list.add(new Student("g",95));
        list.add(new Student("h",69));
        list.add(new Student("i",73));
        list.add(new Student("j",88));
        int sum = 0;
        for (int i = 0; i < list.size(); i++) {
            Student s = list.get(i);
            sum += s.getScore();
        }
        System.out.println("总分是:" + sum);
        double avg = sum/list.size();
        System.out.println("平均分是:" +avg );

        int Max = list.get(0).getScore();
        int Min = list.get(0).getScore();
        for (int i = 0; i < list.size(); i++) {

            Student s = list.get(i);
            int x = s.getScore();
            if (x > Max){
                Max = x;
            }
            if (x < Min){
                Min = x;
            }
        }
        System.out.println("最高分：" + Max);
        System.out.println("最低分：" + Min);

        //学生按分数从高到低依次排序
        System.out.println("学生按分数从高到低依次排序");
        Collections.sort(list);
        System.out.println(list);

        //临时排序
        Collections.sort(list, new Comparator() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getScore() < o2.getScore() ? 1 : ((o1.getScore() == (o2.getScore()) ? 0 : -1));
            }
        });
        System.out.println("学生按分数从高到低依次排序");
        System.out.println(list);

         Collections.max(list);//max自然排序是索引最大
    }
}



package com.hqyj.lls.homework;

import com.hqyj.lls.list.Person;

public class Student implements Comparable{
    private String name;
    private int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

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

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return
                "姓名：'" + name + ''' +
                ", 分数：" + score
                ;
    }

    @Override
    public int compareTo(Student o) {
        return compare(this,o);
    }
    public static int compare(Student s1, Student s2){
        return s1.getScore() < s2.getScore() ? 1 : (s1.getScore() == s2.getScore() ? 0 : -1);
    }
}

7.1 Map根接口
      特点：
        ①存储的是K-V对
        ②无序
        ③key唯一

7.2.实现类
         ①HashMap：底层是数组，链表，红黑树
         ②LinkedHashMap：有序的map
         ③TreeMap：排序的map
         ④HashTable:和HashMao的区别：HashTable线程安全，不常用

 7.3.常用方法

1. put 加入元素(Key,Value)

2. size 集合中k-v队的数量

3. isEmpty 判断是否位空

4. putAll 添加集合

5. get 根据key返回value System.out.println("key为4的value为:" + maps.get(4));

6. containsKey containsValue 是否包含key或value

7.keySet 返回所有键组成集合set

8.values 返回所有值组成的集合

9.entrySet 返回所有键及所有值组成的集合Set

10.clear 清除所有的键值对 maps.clear();

 7.4.原理
        ①怎么初始化的
          1.构造方法中没有做任何的数字初始化
          2.负载因子：
             默认为  0.75f
             元素的数量xx.size / capacity, 是一个最优解，为了增加HashMap性能
          3.最大容量：默认值：2^30
        ②put的原理---HashMap的存储原理?
          0.put方法会初始化位桶Node数组的初始大小，默认为16
          1.put方法存值时，会先计算key的hashCode方法返回的int值，根据hash算法确定当前元素key在位桶中的位置
          2.如果该位置无元素，则直接放入数组中
          3.如果该位置上有元素，则产生了hash冲突(哈希碰撞)
          4.产生hash冲突后，根据key的equals方法判断key是否相等，如果相等。则将key所对应的v覆盖
          5.如果key的equals方法不相等，则采用尾插法将元素插入链表的尾部
          6.当链表长度大于等于7时，链表转为红黑树进行存储
          7.当位桶Node数组大于指定容量(指结合负载因子所计算出来的容量)时，扩容
          8.扩容为原容量的2倍
         建议为每个实体类都增加hashCode方法和equals方法

package com.hqyj.lls.map;


import java.util.*;


public class TestMapMethod {
    public static void main(String[] args) {
        //创建Map对象
        HashMap map = new HashMap<>();
        System.out.println(map.size());

        //put(k,v); 存放数据
        map.put("java",5);
        map.put("c",23);
        map.put("c++",453);
//        map.put("php",54);
        map.put("php",18);
        System.out.println(map);

        //isEmpty(); 集合是否为空
        System.out.println(map.isEmpty());

        //containsKey(k); 集合是否含有某个key
        System.out.println(map.containsKey("java"));

        //containsValue(v); 集合是否含有某个值
        System.out.println(map.containsValue(5));

        //get(k); 根据k获取v
        System.out.println(map.get("java"));

        //remove(k);  根据k值删除key并返回key对应的v
        System.out.println(map.remove("c"));
        System.out.println(map);

        //putAll(map); 存一个集合
        HashMap map1 = new HashMap<>();
        map.put("hello",876);
        map.put("world",213);
        map.putAll(map1);
        System.out.println(map);

        //clear();  清除集合
//        map.clear();

        //keySet();  返回集合所有的键
        Set s1 = map.keySet();
        System.out.println(s1);

        //values(); 返回集合所有的v值
        Collection values = map.values();
        System.out.println(values);

        //map.forEach(k,v); 遍历map输出
        map.forEach((key, value) ->
            System.out.println(key + "：" + value)
        );

        //remove(k,v);以key+value为参数的remove方法 必须key和value都正确才删除
        System.out.println(map.remove("java",5));
        System.out.println(map);

        //replace(key, newV);根据key设置newV,返回旧v

        //replace(k,v，newV);  修改键对应的值
        System.out.println(map.replace("java", 5,777));
        System.out.println(map);

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

        //entrySet(); 遍历集合 获取key值和value值
        Set> set = map.entrySet();
        for (Map.Entry arr : set) {
            String key = arr.getKey();
            Integer value = arr.getValue();
            System.out.println(key + "," + value);
        }


    }
}

  异常处理机制 --- 如何处理异常
    1.抛：方法的后面加throws抛出异常 抛出一个或多个    测试时用，为了代码的可读性
    2.抓：
      try{可能出现异常的d代码} catch(抓取的异常对象){对异常处理的代码}
      try{} catch(){} finally{无论异常发生或者不发生都会执行的代码}
    3.处理异常，如果有多个异常可以直接其父类
    4.通过异常对象可以输出以下常用信息
       消息，原因。堆栈信息
    5.自定义异常
      继承Exception类。重写其对应的方法

package com.hqyj.lls.exception;

import java.io.FileInputStream;
import java.io.FileNotFoundException;


public class TestException {
//    public static void main(String[] args) throws InterruptedException, FileNotFoundException {
public static void main(String[] args) {//抛出异常，也可以直接抛出多个异常
    try {
        //非检测异常
        int[] arr = new int[2];
//        System.out.println(arr[3]);//ArrayIndexOutOfBoundsException

        //检测异常
        Thread.sleep(100);

        FileInputStream fileInputStream = new FileInputStream("11");
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }
}
}