[大数据]大数据学习第11天

1、JavaAPI的学习

1、首要要知道lang下的类是不用导包的
2、要查看方法的返回值，和使用权限
3、对于一个类中的方法也可以直接点进去，查看更加详细的内容

2、Object类

1、equal
   在自定义的类中引用该方法需要重载（可以直接快捷键）
   比较连个对象是否相等，这是我们需要用equal方法
   
public class Demo1 {
    public static void main(String[] args) {
        Stu stu1 = new Stu("zs", 12);
        Stu stu2 = new Stu("zs", 12);
        //这里直接比较的是地址的，new会在堆中开辟出一个新的而地址
        System.out.println(stu1.equals(stu2));//结果是false
        //如果想要比较值的大小，可以在stu中进行一个比较方法
        Stu stu = new Stu();
         boolean a= stu.compare(stu2);
        System.out.println(a);//这是的打印结果就是true
    }
}

public class Stu {
    String name;
    int age;

    public Stu() {
    }

    @Override
    public String toString() {
        return "Stu{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Stu(String name, int age) {
    //这里的this.name可以默认是实例化的第一个
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        return super.equals(obj);
    }

    public boolean compare(Stu stu){
        return this.name==name&&this.age==age;
    }
}

3、toString

toString主要是对成员变量进行格式化的输出

4、包装类

1、包装类：Java为我们提供了对象基本数据类型的封装类，里面提供了一些方法，可以用于处理类型的转换，简而言之，包装类就是被包装起来的类
2、包装类和基本数据类型相互之间是可以转化的
3、由基本数据类型转换成包装类：装箱（手动 自动）(大部分情况是用自动的)
4、为什么有了基本数据类型之后还会有包装类？
   1、重要的是集合中是不让放基本数据类型的，只能存放引用数据类型（Object o），也就是包装类，包装类是引用数据类型
   2、解百纳数据类型可以和包装类型直接进行转换，自动装箱拆箱
   3、通过包装类型的parse方法可以实现基本数据类型与String类型之间的转换
   4、函数需要传进去的参数为Object类型，传入基本数据类型就不可以

手动装箱
        int i = 10;
        Integer integer = Integer.valueOf(i);
手动拆箱
        int i = 10;
        Integer integer = Integer.valueOf(i);
        int b = integer.intValue();
自动装箱
        int a = 12;
        Integer c = a;
自动拆箱
        int a = 12;
        Integer c = a;
        int d = c;

//只有在重载中才会用到手动的装箱和拆箱
//如果在一个类的重载方法中，有两个方法的参数类型，一个是基本数据类型，一个是对应的包装类型。此时，将无法使用自动装箱和拆箱。必须通过手动的装箱和拆箱完成对应的调用。
public class Demo1 {
    public static void main(String[] args) {
        show(10 );//此时会优先调用int型的show方法
        show(Integer.valueOf(10));//这是才会打印Integer方法
    }

    public static void show(int a){
        System.out.println(a);
    }
    public static void show(Integer a){
        System.out.println(a);
    }
}

5、享元原则

是程序设计的一个基本原则。当我们需要在程序中频繁使用到一些元数据的时候，此时，我们可以提前将这些元数据准备好，当需要的时候，直接拿过来使用即可。使用完成之后，也不进行销毁，以便下次继续使用。

//在Integer中，将[-128,127]范围内的数字对应的包装类对象预存到了一个Integer.cache数组中，每当我们用到这个范围内的数字的时候，可以直接从这个数组中获取到元素。如果用到这些不在这个范围内的数字，再去进行新的包装类对象的实例化。这样，不用频繁的开辟空间，销毁空间，节省了CPU资源
public class Demo1 {
    public static void main(String[] args) {
        Integer a = Integer.valueOf(10);
        Integer b = Integer.valueOf(10);
        System.out.println(a==b);//此时答案为true

        Integer c = Integer.valueOf(200);
        Integer d = Integer.valueOf(200);
        System.out.println(c==d);//此时答案为false
    }
}

6、字符串与基本数据类型的转换

1、基本数据类型转成字符串
public class Demo1 {
    public static void main(String[] args) {
        //1、int->String 基本数据类型转成字符串
        int a = 10;
        String str = String.valueOf(a);
        //2、String->int 字符串转成基本数据类型
        int b = Integer.parseInt("123");
    }
}
//二进制的字符串1234转十进制的数
public class Demo2 {
    public static void main(String[] args) {
        int a = Integer.parseInt("1010",2);
        System.out.println(a);//结果为10
    }
}

7、进制间的转换

把十进制转成其它进制
Integer.toHexString() 转十六进制
Integer.toOctalString() 转八进制
Integer.toBinaryString() 转二进制

public class Demo1 {
    public static void main(String[] args) {
    //把一个十进制的数转换成二进制的数，但是这个数是以字符串的       形式展现出来的，必须写字符串形式，不然会报错
        String a = Integer.toBinaryString(10);
        System.out.println(a);
    }
}

8、Character类

isLetter()//确定指定字符是否为字母
public class Demo3 {
    public static void main(String[] args) {
          System.out.println(Character.isLetter('A'));//true
        System.out.println(Character.isLetter(1));//false
    }
}

isLowerCase()//确定指定字符是否是小写字母
 System.out.println(Character.isLowerCase('a'));//true

isLetterOrDigit()//确定指定字母是否是字母或数字
System.out.println(Character.isLetterOrDigit('a'));//true

9、常用类Math

是一个数学类，这个类中封装了很多用来做数学计算的方法，当我们需要用到数学计算的时候，要能够想到这个类。这个类中有很多封装好的数学公式，而且都是静态方法，方便调用。

public class Demo1 {
    public static void main(String[] args) {
        int a =-1;
        //求绝对值的
        System.out.println(Math.abs(a));
        //四舍五入
        double b = 1.2;
        System.out.println(Math.round(b));
        //向上取整
        System.out.println(Math.ceil(b));
        //向下取整
        System.out.println(Math.floor(b));
        //求指定次幂
        System.out.println(Math.pow(2, 3));
        //求一个数的开平方
        System.out.println(Math.sqrt(4));
        //求一个随机数[0,1)
        System.out.println(Math.random());
    }
}

10、常用类Random

是一个负责专门产生随机数的类。在Java中，Random类在java.util包中。所以在使用之前需要导包。
其实，随机数产生是有一个固定的随机算法的。代入一个随机种子，能够生成一个随机数列。但是由于算法是固定的，因此会有一个“BUG”，如果随机种子相同，则生成的随机数列也完全相同。

public class Demo1 {
    public static void main(String[] args) {
        //需要实例化Random
        Random random = new Random();
        //如果nextInt中不写参数，表明随机产生一个
        //写了参数，标明是0到参数之间的一个整数
        System.out.println(random.nextInt(10));
        //有种子,此后打印的都是一个值
        Random random1 = new Random(1);
        System.out.println(random1.nextInt(5));
    }
}

11、常用类BigInteger、BigDecimal

这两个类都是用来表示数字的数，BigInteger表示整型数字，BigDecimal表示浮点型数字。这两个类，可以用来描述非常、非常、非常大的数字。列如整数，long是最大的表示范围，但是即便是long型，也有它表示不了的情况。BigInteger就是可以表示任意大小的数字。

//在使用时，需要先实例化
BigInteger bigInteger = new BigInteger("133462526567576576256256526546525765457542");

//对这个超大的数字进行加减乘除运算
public class Demo2 {
    public static void main(String[] args) {
        BigInteger bigInteger = new BigInteger("133462526567576576256256526546525765457542");
        BigInteger bigInteger1 = new BigInteger("3326847664518561661661786864");
       //两数相加
        System.out.println(bigInteger.add(bigInteger1));
        //两数相减
        System.out.println(bigInteger.subtract(bigInteger1));
        //两数相乘
        System.out.println(bigInteger.multiply(bigInteger1));
        //两数相除
        System.out.println(bigInteger.divide(bigInteger1));
        //相除，保留商和余数
        BigInteger[] bigIntegers = bigInteger.divideAndRemainder(bigInteger1);
        System.out.println(bigIntegers[0]);//商
        System.out.println(bigIntegers[1]);//余数
    }
}

12、常用类Date

是一个用来描述时间、日期的类。在java.util包中

import java.util.Date;

public class Demo3 {
    public static void main(String[] args) {
        //创建时间对象
        Date date = new Date();
        //输出当前时间
        System.out.println(date);
        //输出的是1970年1月1号8:00后的1000毫秒
        Date date1 = new Date(1000);
        System.out.println(date1);
        //求年
        Date date2 = new Date();
        //获取年，但是要加上1900年，
        int year = date2.getYear();
        //获取月,但是月要加1，因为月是从0开始的
        int month = date2.getMonth();
        //获取天,这里获取天数是用getDate
        int day = date2.getDate();
        //获取小时
        int hours = date2.getHours();
        System.out.println(year+1900);
        System.out.println(month);
        System.out.println(day);
        System.out.println(hours);
        //打印未来的某一个时间
        Date date3 = new Date();
        date3.setHours(21);
        date3.setMinutes(10);
        date3.setSeconds(0);
        System.out.println(date3);
        long time = date3.getTime();
        //打印从1970年到未来时间的有多少毫秒
        System.out.println(time);
        //打印未来到现在有多少毫秒
        Long day4 =date3.getTime()-date.getTime();
    }
}

13、常用来SimpleDateFormat

import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo4 {
    public static void main(String[] args) {
        //实例化现在时间
        Date date = new Date();
        //使用日期格式化工具
        SimpleDateFormat simple = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //把现在时间格式化
        String format = simple.format(date);
        //输出格式化后的时间
        System.out.println(format);
    }
}

14、常用类Calendar

1、是一个用来描述时间、日期的类。比Date的功能更加完善。在Date类中，有很多方法都已经被废弃了。用Calendar类中的某些方法代替
2、与其他语言环境不一样，Calendar提供了一个类方法getInstance，以获得此类的一个通用的对象

//get()是返回给定日历字段的值
public class Demo6 {
    public static void main(String[] args) {
        //通过抽象类方法来获取当前抽象类的对象进行使用
        Calendar instance = Calendar.getInstance();
        //这里的YEAR是常量
        System.out.println(Calendar.YEAR);
        //1代表年,2代表月（但是也要加1），11代表时
        //在这里重点注意的时需要用到get（）方法
        System.out.println(instance.get(1));
        System.out.println(instance.get(Calendar.MONTH));
        System.out.println(instance.get(11));
    }
}

15、枚举

定义枚举类型，需要使用到关键字enum。枚举的名字是一个标识符，通常情况下字符都要大写，表示一个常量。
枚举是一种特殊的类，其实枚举可以认为是Object类的一个最终子类。不能被其他类、枚举继承

public enum Gender {
    //将这个枚举对象所有可能的取值，都列出来
    //枚举中的元素，也是标识符，遵循大驼峰命名法
    Male,Female;
}
public class Demo8 {
    public static void main(String[] args) {
        //直接就可以进行引用
        Gender str = Gender.Female;
        switch (str){
            case Male:
                System.out.println("1234");
                break;
            case Female:
                System.out.println("12334");
                break;
        }
    }
}

public enum Gender {
    //将这个枚举对象所有可能的取值，都列出来
    //枚举中的元素，也是标识符，遵循大驼峰命名法
    Male("男"),Female("女");
    //定义属性
    public String desc;
    //对定义的枚举进行解释
    Gender(String desc){
        this.desc = desc;
    }

    //定义方法
    public static void shoe(){
        System.out.println("1233");
    }

}

public class Demo8 {
    public static void main(String[] args) {
        //直接就可以进行引用
        Gender str = Gender.Female;
        System.out.println(str);
    }
}

16、异常

在Java中程序不正常的情况一般分为两种：Exception和Error
在程序在运行时，会自动的捕获代码中所有出现的异常情况，然后有JVM自行处理（输出错误结果）
异常分为两种：
    1、交给JVM自行处理
    2、手动处理
       try{
           可能出现异常的代码；
       }catch(异常对象){
           解决方法;
       }

//一个catch
try {
            int a = 0;
            int b = 3;
            System.out.println(b/a);
        }catch (ArithmeticException an){
            an.printStackTrace();
        }

//多个catch
try {
            int a = 0;
            int b = 3;
            System.out.println(b/a);
        }catch (ArithmeticException an){
            an.printStackTrace();
        }catch (ArrayIndexOutOfBoundsException an){
            an.printStackTrace();
        }

//简介写法
  try {
            int a = 0;
            int b = 3;
            System.out.println(b/a);
        }catch (Exception an){
            an.printStackTrace();
        }
        //直接写各种异常的父类Exception，无论什么情况都能捕获到

//如果有异常也可以把这个抛出异常写在方法的后面，只是关键字变成throws
public static void main(String[] args) throws Exception{}

//自定义异常
//写自定义异常时必须继承异常的父类Exception
public class Demo1 extends Exception{
    //创建构造方法
    public Demo1(){
        //调用父类的方法
        super("出现异常");
    }
}
public class Demo2 {
    public static void main(String[] args) throws Exception{
        Scanner scanner = new Scanner(System.in);
        int age = scanner.nextInt();
        if ( age >= 0){
            System.out.println("您输入的没有错误");
        }else{
            //调用自定义异常
            throw new Demo1();
        }
    }
}