2.6+2.7 笔记

6.4 Math

是数学相关的类，数学相关的数据和方法

public final class Math extends Object{
    private Math() {}
}

注意Math不允许有子类，不允许实例化对象，因此所有的属性和方法全部静态，Math.XX

6.4.1 属性

属性名	含义	用法
PI	圆周率	Math.PI
E	自然底数	Math.E

6.4.2 方法

方法名	用途	参数	返回值
abs (int a)	绝对值		返回绝对值
double floor (int a)	向下取整		返回比参数a小的整数，a整数返回自己
double ceil (int a)	向上取整		返回比参数a大的整数，a整数返回自己
int round (float)	四舍五入	小数	返回取整整数(long)Math.floor(a+0.5d)
double pow(a,b)	次幂		a的b次幂
sqrt(a)	平方根		a的平方根
random()	随机数		[0,1)的随机小数

随机数【a,b】公式

(int)((b-a+1)*Math.random()+a);

练习：

生成4位随机验证码[字母，不分大小写;无重复]
1.数组，去重复
2.stringBuilder append()

public class M01 {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(random2());
    }
    
    //StringBuilder方法
    public static StringBuilder random() {
        StringBuilder b = new StringBuilder();
        for(int i=0;i<4;i++) {
            char c=(char)(('z'-'A'+1)*Math.random()+'A');
            if(c>'Z'&&c<'a') {
                i--;
                continue;
            }else {
                if(b.indexOf(c+"")!=-1) {
                    i--;
                    continue;
                }else
                    b.append(c);
            }
        }
        return b;
    }
    
    //数组方法
    public static String random2() {
        char [] str = new char [4];
        for(int i=0;i<str.length;i++) {
            char c=(char)(('z'-'A'+1)*Math.random()+'A');
            if(c>'Z'&&c<'a') {
                i--;
                continue;
            }else {
                //去重
                for(int j=0;j<i;j++) {
                    if(c==str[j]) {
                        i--;
                        break;
                    }
                }
                str[i]=c;
            }
        }
        return new String(str);
    }
}

6.5 包装类

包装类是java八个基本数据类型，封装成一个类。八个包装类对应的是八个数据类型。

6.5.1 包装类

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

Integer/Double

属性：
MAX_VALUE 最大值
MIN_VALUE 最小值

构造方法：
int i = 10;
new Integer(i);

方法：
parseInt(字符串);
toHexString(int); //16进制

6.5.2 装箱和拆箱

装箱：将基本数据类型转化包装对象
拆箱：将包装对象转化为基本数据类型做运算

//手动装箱和拆箱
Integer a = new Integer(10); //手动装箱
int b = a.intvalue(); //手动拆箱

//自动装箱和拆箱 jdk5.0+
Integer a = 10; //自动装箱
包装对象 = 基本数据类型;

int b = a;  //自动拆箱
基本数据类型 = 包装对象;

注意：装拆箱时，必须满足左右两侧类型匹配，不支持类型转换

//机制
public class xiang {
    public static void main(String[] args) {
        //自动装箱
        //机制：数值128以上各自空间，128以下采用常量池
        Integer a=127;
        Integer b=127;
        
        Integer c=128;
        Integer d=128;
        
        Integer e= new Integer(10);
        Integer f= new Integer(10);
        
        Double a1=10.0;
        Double a2=10.0;
        
        System.out.println(a==b);
        System.out.println(c==d);
        System.out.println(e==f);
        System.out.println(a1==a2);
    }

}

6.5.3 包装类和String的转化

1. 其他数据类型转化String
      int  a = 10;
    a.  String s1 =a+"";  //拼接
    b.  Integer a=10
            System.out.println(a.toString());  //对象.调用toString
    c.  System.out.println(String.valueOf(a));  //返回 int 参数的字符串表示形式
    
2. String 变成基本数据类型
    Integer.parseInt(字符串);   //整数
    Double.parseDouble(字符串);  //小数

异常： NumberFormatException

---

6.6 Object

类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

构造方法：

new Object(); 

public class Student {
    public Student() {
        super();
    }
}

方法：

方法名	用途	参数	返回值
equals()	判断对象地址，可重写		Boolean
toString()	getClass().getName() + '@' + Integer.toHexString(hashCode())
hashCode()	每个对象有唯一的哈希码，哈希表结果分配		int
finalize()	垃圾回收方法，GC机制，虚拟机自动调用，算法，覆盖
wait()	线程等待
notify()	线程唤醒
notifyAll()	唤醒所有线程

@Override
    public boolean equals(Object obj) {
        if(obj instanceof Student) {
            Student s = (Student)obj;
            if(s.getName().equals(this.name)) {
                return true;
            }
        }
        return false;
}

final修饰符 ， 常量，final类和方法
finally{} 语句块， 异常捕获机制，无条件执行块
finalize() 方法， 垃圾回收方法

练习： 定义Student，属性： 学号 姓名，覆盖equals()和toString() , 当学号和姓名相同，同一个对象

---

6.7 Class【反射】

---

6.8 集合类 【java.util】

集合类是JAVA中数据存储介质。数据存储【变量，数组，集合，文件系统，数据库 】

特点：

1.不限制大小，随意增删改查
2.对象型操作【类】
3.集合的数据类型操作灵活

6.8.1 集合体系结构 ※

Collection 接口    
【直接存储值】            
            List子接口
            【有下标，可以重复】
                  ArrayList 实现类    线性集合，线性存储集合【元素一个挨着一个，适合查找，不适合更新】
                                       线程不安全，不同步的，效率高，速度快
                    
                  LinkedList            链式集合，链式存储集合【元素不是挨着，适合更新，不适合查找】
                    Vector               线程安全，同步的，效率低，速度慢
            Set子接口
            【没有下标，不可以重复】
                    HashSet             哈希表，无序的，不能重复
                    TreeSet               红黑树， 有序的【自然排序】，去重


Map 接口
【直接存储键值对】
            HashMap 实现类                 允许空值空键
                                       线程不安全，不同步的，效率高，速度快
            
            Hashtable 实现类             反之
            
            TreeMap 实现类                 自然排序

6.8.2 ArrayList集合

List接口的实现，允许null，扩容的数组结构，底层判断数组大小的机制。

构造方法：

new ArrayList<E>(); // 容量10
new ArrayList<E>(int c); // 容量c
new ArrayList<E>(Collection c); // 多态方式创建

注意： <E> 泛型，泛指的类型。E指定后，集合只能存储该类型的数据，不指定默认是Object

    //集合存储整数
    ArrayList<Integer> list = new ArrayList<Integer>();
    //集合存储字符串
    ArrayList<String> list2 = new ArrayList<String>();
    //集合存储学生对象
    ArrayList<Student> list3 = new ArrayList<Student>();

方法：下标，从0开始，有序

方法名	含义	参数	返回值
add(E e)	尾部追加	E指定类型的元素	boolean
add(int index,E e)	在指定下标之前插入元素	index下标e元素
remove(下标)	根据下标删除	下标
remove(元素)	根据元素删除	元素
clear()	集合清空
set(int index,E e)	指定位置元素修改	index下标 e元素	E
size()	集合大小		int
get(下标)	根据下标返回元素	下标	E
contains(E)	判断是否存在		boolean
indexOf()	查找是否存在		下标
lastIndexOf()	查找是否存在

范例：

//添加元素[自动装箱]
        list.add(1);
        list.add(222);
        list.add(3);
        list.add(8);
        
        //插入元素
        list.add(1, 888); //下标1的位置插入
        
        //删除元素
        list.remove(2); //删除下标为2的
        list.remove(new Integer(888)); //集合内的是对象，删除元素先装包
        
        //修改元素
        list.set(1, 666); //修改下标为1的元素
        
        //集合大小
        System.out.println(list.size());
        
        //根据下标返回元素
        System.out.println(list.get(0)); //返回下标位置的元素
        
        //遍历
        for(int i = 0 ; i < list.size() ; i++) {
            System.out.println(list.get(i));
        }
        
        //增强for循环遍历
        for(Integer a : list) {
            System.out.println(a);
        }
        
        //查找
        System.out.println(list.indexOf(100)); //查找元素位置，没有返回-1
       
        System.out.println(list);

6.8.3 HashSet集合

Set子接口的实现类，不能保证顺序，不能重复。
基于哈希表的存取结构。

构造方法：

new HashSet<E>();
new HashSet<E>(int c);
new HashSet<E>(Collection c);

方法：

方法名	含义	参数	返回值
add(E e)	添加非存在的元素	E指定类型的元素	boolean
remove(E e)	删除元素	E删除的元素
clear()	清空
size()	集合大小		int
iterator()	迭代器方法	Iterator迭代器接口

Iterator迭代器接口：

方法名	含义	参数	返回值
hasNext()	判断是否存在下一个		boolean
next()	向下取出一个元素		E
remove()	删除元素

例子：

import java.util.HashSet;
import java.util.Iterator;

public class set01 {
    public static void main(String[] args) {
        HashSet<String> set =new HashSet<String>();
        
        set.add("www");
        set.add("hhh");
        set.add("sss");
        set.add("whs");
        set.add("www");
        
        //System.out.println(set.size()); //大小  4
        //System.out.println(set);  // www hhh sss whs
        
        //set.remove("sss");  //删除 sss
        //System.out.println(set); // whs www hhh
        
        //set.clear();  //清空
        //System.out.println(set); // []
        
        //遍历
//        for(String s : set) {
//            System.out.println(s);
//        }
        
        //获得迭代器接口：扫描Set集合元素
        Iterator<String> itr = set.iterator();
        while(itr.hasNext()) { //判断存在下一个
            System.out.println(itr.next());
        }
    }
}

练习： 去重复，给定数组【10，35，10，28，68，92，35】 去重复后遍历

public class TestSet2 {
    public static void main(String[] args) {
        //int[] a = { 10, 35, 10, 28, 68, 92, 35 };
        List<Integer> list = Arrays.asList(10, 35, 10, 28, 68, 92, 35);
        HashSet<Integer> set = new HashSet<Integer>(list);
        //基本方式添加
//        for (int i = 0; i < a.length; i++) {
//            set.add(a[i]);
//        }
//        System.out.println(set);
        //Object [] b = new ArrayList<Integer>(set).toArray();
        System.out.println(set);
        
        
    }
}

6.8.4 TreeSet集合

红黑树，对元素实现自然排序。【排序策略 ； 提供比较器】

构造方法：

new TreeSet<E> ();
new TreeSet<E> (Collection c);
new TreeSet<E> (Comparator c);//提供比较器

方法：同HashSet,比HashSet更多。

排序底层机制：

1. 实体实现Comparable接口 覆盖CompareTo()； Integer，String已经实现
2. 比较器

public class Fruit implements Comparable<Fruit>{
    @Override
    public int compareTo(Fruit o) {
        if(this.price == o.getPrice()) {
            if(this.no > o.getNo()) {
                return 1;
            }else {
                return -1;
            }
        }else if(this.price > o.getPrice()) {
            return 1;
        }else {
            return -1;
        }
    }

}


        TreeSet<Fruit> set3 = new TreeSet<Fruit>();
        set3.add(new Fruit(1, "山竹", 55, 200));
        set3.add(new Fruit(2, "草莓", 55, 100));
        set3.add(new Fruit(3, "芒果", 35, 50));
        System.out.println(set3);

总结区别：

1. java.lang.Comparable接口 ; 覆盖compareTo(Object o), 类实现接口，该类的所有对象均按照规则排序，固定的排序模式，灵活性差。
2. java.util.Comparator接口 ; 覆盖compare(o1,o2),每次创建TreeSet都提供比较器实现类对象，实现每次定制需求的比较机制。

比较器：

import java.util.Comparator;
import java.util.TreeSet;

import com.qf.homework.Student;

public class TestStudent {
    public static void main(String[] args) {
        //按照学生成绩排序
//        TreeSet<Student> list2 = new TreeSet<Student>(new Comparator<Student>() {
//
//            @Override
//            public int compare(Student o1, Student o2) {
//                if(o1.getScore() > o2.getScore()) {
//                    return -1;
//                }else if(o1.getScore() < o2.getScore()) {
//                    return 1;
//                }else {
//                    return o1.getName().compareTo(o2.getName());
//                }
//                
//            }        
//        });
        
        //按照学生学号排序
//        TreeSet<Student> list = new TreeSet<Student>(new Comparator<Student>() {
//
//            @Override
//            public int compare(Student o1, Student o2) {
//                return o2.getSno() - o1.getSno();
//                
//            }        
//        });
        //学号排序，lambda
        TreeSet<Student> list = new TreeSet<Student>((o1,o2)-> {return o1.getSno() - o2.getSno();});
        
        
        list.add(new Student("张三", 1, "男", 99));
        list.add(new Student("李四", 2, "女", 90));
        list.add(new Student("王五", 3, "男", 99));
        list.add(new Student("陈六", 4, "女", 100));
        list.add(new Student("王三", 7, "男", 75));
        list.add(new Student("王四", 8, "男", 85));
        
        //遍历集合
        for (Student s : list) {
            System.out.println(s);
        }
        
    }
}

练习： 定制比较器：定义一个字符串集合，按照字符串的长度排序，如果相同按照字典顺序。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;

public class set01 {
    public static void main(String[] args) {
        
        //字符串长度排序  匿名内部类方法
/*        TreeSet<String> s = new TreeSet<String>(new Comparator<String>() {

            @Override
            public int compare(String o1, String o2) {
                // TODO Auto-generated method stub
                if(o1.length()==o2.length()) {
                    return o1.compareTo(o2);
                }else {
                    return o1.length()-o2.length();
                }
                
                //return o1.length()==o2.length() ? o1.compareTo(o2) : o1.length()-o2.length();
            }
        });
*/        
        //lamda方法
/*        TreeSet<String> s2 = new TreeSet<String>((o1,o2)-> o1.length()==o2.length() ? o1.compareTo(o2) : o1.length()-o2.length());
        
        s2.add("abc");
        s2.add("def");
        s2.add("g");
        s2.add("hl");
        s2.add("acddd");
        
        //遍历
        for(String str : s2) {
            System.out.println(str);
        }
*/        
              
    }    

}