javaSE基础06(final,常用类,基本数据类型的封装)-526互联

Final关键字(用法:类不想被人继承 ):

修饰类：最终的类,不可以被继承比如String；
修饰方法：方法不可以被重写；
修饰属性：不可以被重新赋值,但是可以改变变量里的内容;

public class Student {
    String name;
    public static void main(String[] args) {
        final Student stu=new Student();
//        stu=new Student;新对象不能赋给stu
        stu.name="张三";
    }

不可变量

成员不可变量可以不直接赋值,但是必须再构造方法中赋值

  final int sex;//成员不可变量可以不直接赋值,但是必须再构造方法中赋值
    public Student() {
        sex=12;
    }
    public Student(int sex) {
        this.sex=sex;
    }

常量

用public static final 来修饰;
常量名一般要大写；
必须给与初始值;(用static修饰才是类的)；

也可以再静态代码块中初始化；

        public static final int a;
        static {
         a=23;
        }

object

所有的引用类型默认继承object；
object是所有引用类型的超级父类；
object中的属性和方法：toString equals hashcode

== 和 .equals

== 在引用类型中比较的是是否是同一个对象，比较内存地址是否是同一个；
在基本数据类型中==比较的是值是否是一样的；
.equals 定义在Object里，比较引用类型的对象内容是否是一样，使用equals方法，自定义类中需要重写equals;
String会重写Object里的equal方法，会判断字符串内容相不相等；

String

以值的方法声明字符串, String str="123";
String长度 String.length( )，原字符串永远不会发生变化;

获取字符串内容；

    str=new String("123");
        for(int i=0;i<str.length();i++){
            System.out.println(str.charAt(i));
        }

获取下标对应得字符charAt
```
char c=str.charAt(4);
```

截取字符串 substring

String substr=str.substring(6,14);

String substr=str.substring(6);//打印包括下标6在内的以后的所有数

//substring（StartIndex，endIndex） 左闭右开

截取字符串的案例：

//定义一个方法,接受一个字符串,接受一个整数num,将这个字符串切割成每num个字符为一段的数组 
    public static String[] accept0(String str, int num) {
        int count = str.length() / num + (str.length() % num == 0 ? 0 : 1);
        String[] strs = new String[count];
        for (int i = 0; i < count; i++) {
            if (str.length() <= num) {
                strs[i] = str; 
            } else {
                strs[i] = str.substring(0, num);
                str = str.substring(num);
            }
        }
        return strs;
    }

查找子串出现的位置（下标）indexof；用法：总字符串.indexof("") 关键点：找不到对应的数据要返回-1；

int index=str.indexOf("2023");//从前往后找
       index=str.lastIndexOf("2");//从后往前找 都找的第一遇到字符的位置

分割字符串；

    str="12345.123.4523.45";
    String[] arr=str.split("\\.");
//regex正则表达式  .代表任意字符 \\.java转译 正则表达式转译
    System.out.println(Arrays.toString(arr));

去除前后空白位置：

str="  123   123   123";
String res=str.trim();//去除前后空白位置
System.out.println(res);

把字符都转换为小写或大写；

//5把字符都转换为小写
        str.toLowerCase();
        //把字符转换为大写
        str.toUpperCase();

拼接字符串 + 拼接完得到的都是字符串；

        str="123"+"123"+str;
        str="123"+new Object();
        //+ 的优先级是一样的
        System.out.println(12+23+"");//35
        System.out.println(""+12+23);//1223

验证A串是否是B串的子串；

public boolean method(String big,String small){
        if (big==null){
            return false;
        }
        int index=big.indexOf(small);
        return index!=-1;
    }

字符串拼接

因为字符串+拼接会产生很多中间量，并且这些中间量会永久占用空间；
所以尽量避免使用+拼接字符串的形式，循环；
解决方案，使用一个数组存储要拼接的数据，拼接完成后转成字符串，可以有效避免中间量的生成；

工具类：

StringBuilder；

        StringBuilder stringBuilder=new StringBuilder();
        //拼接
        stringBuilder.append("123");//追加
        for(int i=1;i<=9;i++){
            stringBuilder.append(i);
        }
        String str=stringBuilder.toString();//拼接完成的数组转化成字符串
        System.out.println(str);
        //new StringBuilder(12)  StringBuilder对象的value书组长度默认是12
        //new StringBuilder("ab")创建StringBuilder对象并将”ab“拼接在value数组

        //默认长度
        //StringBuilder的value默认长度是16
        //扩容
        //原来容量的双倍+2
    }

StringBuffer；

随机数

第一种方法：double d=Math.random();
第二种方法：Random r =new Random（）/（12）种子数；

math

向上取整（得到的浮点型）

double d1=Math.ceil(12.2222);//返回double类型  结果为13.0

向下取整
```
double d2=Math.floor(12.99999);
```

四舍五入（返回整数类型） double会返回long类型，float会返回int类型

//正数四舍五入，负数五舍六入
        long l1=Math.round(12.2);//注意会隐式转换

取绝对值
```
int a= Math.abs(-12);
```

时间戳

        long ctm=System.currentTimeMillis();//返回当前时间
        System.out.println(ctm);
        System.gc();//呼叫垃圾回收
　　　　　system.exit(0)//退出，下面程序不会再进行

把Date数据类型转化成yyyy-MM-dd HH:mm:ss SSS类型，（返回当前时间）

        Date date =new Date();
        System.out.println(date);
        //把date日期格式化转化成yyyy-MM-dd HH:mm:ss SSS
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        String sdfstr=sdf.format(date);
        System.out.println(sdfstr);

Calender 日历类

自定义时间

        //Calendar日历类 没有公共的构造方法 protected
        Calendar c=Calendar.getInstance();
        c.set(Calendar.YEAR,3023);//自定义年份
　　     int year =c.get(Calendar.YEAR);//获取定义的年份

将日历类型数据转化

        c.getTimeInMillis();//long类型，date对象的时间戳
        c.getTime();//返回当前的日历对象对应的Date对象

基本数据类型的封装

java为了达到万物皆对象的理念，每一个基本数据类型都提供了封装类型；
封装类型包括Byte Short Intrger Long Float Double Charcter；
字符串转成 int数组的方法；
```
int num=Integer.parseInt("123");
```

装箱和封箱；

        Integer b=12;//装箱：将基本数据类型装缓存对应的封装类型
        int a=new Integer(12);//拆箱：将基本数据类型的封装类型的对象转化成基本数据类型的值
        //缓存

基本数据类型的封装类型：整数类型和字符类型会默认缓存-128~127每一个数值浮点型没有缓存；

        Integer i4=212;
        Integer i5=212; 
        System.out.println(i4==i5);//超出封装范围 所以为false
　　    //Integer类型可以通过-XX:AutoBoxCacheMax 数值  来修改默认缓存的数组

基本数据类型的封装类型之间没有隐式转换；

        Integer i1=12;
        Byte b1=127;
//      i1=b1;基本数据类型的封装类型之间没有隐式转化

不能使用双等号进行跨类比较；

//        System.out.println(i1==b1);如：Integer和Byte

valueOf("") 将其中的内容取出，转成当前类的类型；

        Integer u=Integer.valueOf("123");//将其中的内容取出，转成当前类的类型

javase-day常用javase day