装箱

包装类

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

例:基本数据类型与字符串之间的转换

Integer.toBinaryString()

Integer.MAX_VALUE;//int类型的最大值
Integer.MIN_VALUE;//int类型的最小值

Integer i1 = new Integer(100);//100
Integer i1 = new Integer("100");//100

Integer i1 = new Integer("abc");
//报错:java.lang.NumberFormatExcetion数字格式异常

//int转字符串
int i = 100;
i1.toString();//返回i1值的字符串
String s1 = i+"";//推荐
String s2 = String.valueOf(i);//推荐

八中基本数据类型的包发装类中,其中其中都有parseXxx(),可以将这七中字符串表现形式转换成基本数据类型(char的包装类Character没有parseXxx()方法,char只能存一个字符,字符串到字符的转换可以通过toCharArray())

//jdk1.5前:
int x = 100;
Integer i = new Integer(x);//将基本数据类型包装成对象,装箱
int y = i.intValue();//讲对象转换为基本数据类型,拆箱

//jdk1.5后:实际上使用的还是上面的方法
Integer i1 = 100;//自动装箱,把基本数据类型转换成对象
int z = i1 + 200;//自动拆箱,把对象转换为基本数据类型

//底层调用i2.intValue(),但是i2是null,null调用方法就会出现空指针异常(java.lang.NullPointerException)
Integer i2 = null;
int a = i3 +100;

包装器的缓存：

Boolean：(全部缓存)
Byte：(全部缓存)
Character(<= 127缓存)
Short(-128 — 127缓存)
Long(-128 — 127缓存)
Integer(-128 — 127缓存)
Float(没有缓存)
Doulbe(没有缓存)

例:Integer 的valueOf()内部有一个Integer cache[]数组,保存了-128
到127,值在数组中会直接取数,不在的话new一个Integer对象;
所以:

Integer i1 = 127;
Integer i2 = 127;
System.out.println(i1==i2);//true
System.out.println(i1.equals(i2));//true    内部重写了equals方法

Integer i3 = 128;
Integer i4 = 128;
System.out.println(i1==i2);//false    超出范围 new了两个Integer对象
System.out.println(i1.equals(i2));//true

String的相关方法

String

String是不可变字符串,字符串是常量,一旦被赋值,就不能被改变.再次赋值时原来的字符串就变成了垃圾.
字符串字面值”abc”可以看做一个字符串对象.
String类重写了toString()方法,返回的是该对象本身.
*常见构造方法
* public String():空构造
* public String(byte[] bytes):把字节数组转成字符串
* public String(byte[] bytes,int index,int
length):把字节数组的一部分转成字符串
* public String(char[] value):把字符数组转成字符串
* public String(char[] value,int index,int
count):把字符数组的一部分转成字符串
* public String(String original):把字符串常量值转成字符串

• String类的判断功能

  • boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
  • boolean equalsIgnoreCase(String
    str):比较字符串的内容是否相同,忽略大小写
  • boolean contains(String str):判断大字符串中是否包含小字符串
  • boolean startsWith(String
    str):判断字符串是否以某个指定的字符串开头
  • boolean endsWith(String
    str):判断字符串是否以某个指定的字符串结尾
  • boolean isEmpty():判断字符串是否为空。

• String类的获取功能

  • int length():获取字符串的长度。
  • char charAt(int index):获取指定索引位置的字符
  • int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
  • int indexOf(String
    str):返回指定字符串在此字符串中第一次出现处的索引。
  • int indexOf(int ch,int
    fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
  • int indexOf(String str,int
    fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
  • lastIndexOf
  • String substring(int
    start):从指定位置开始截取字符串,默认到末尾。
  • String substring(int start,int
    end):从指定位置开始到指定位置结束截取字符串。

• String的转换功能：

  • byte[] getBytes():把字符串转换为字节数组。

  • char[] toCharArray():把字符串转换为字符数组。

  • static String valueOf(char[] chs):把字符数组转成字符串。

  • static String valueOf(int i):把int类型的数据转成字符串。

    • 注意：String类的valueOf方法可以把任意类型的数据转成字符串

  • String toLowerCase():把字符串转成小写。(了解)

  • String toUpperCase():把字符串转成大写。

  • String concat(String str):把字符串拼接。

• A:String的替换功能

  • String replace(char old,char new)
  • String replace(String old,String new)

• B:String的去除字符串两空格

  • String trim()

• C:String的按字典顺序比较两个字符串

  • int compareTo(String str)

  • int compareToIgnoreCase(String str)

    byte[] arr1 = {96,97,98};
    String s2 = new String(arr1);//解码,abc

StringBuilder

StringBuilder一个可变的字符序列.在原空间更改当频繁改变字符串值时,使用此类内存利用率高.非线程安全
StringBuffer 线程安全，可变的字符序列

.append() 在末尾追加字符串
.insert(i,"a") 插入到指定索引位置
.delete(start,end) 删除指定位置
.reverse();字符串反转
.
String str = sb.subString(0,4); 截取字符串,返回字符串

当频繁改变字符串值时,StringBuilder最快,StringBuffer其次,String最慢

String–>StringBuffer:
1)StringBuffer sb1 = new StringBuffer(“heima”);//通过构造方法转换
2)StringBuffer sb1= new StringBuffer();
sb1.append(“heima”);

StringBuffer–>String
1)String s1 = new String(sb1);//通过构造方法转换
2)String s2 = sb1.toString();
3)String s3 = sb.subString(0,sb.length());//截取字符串转换

时间方法

//获取系统时间
Date dt = new Date();//当前时间
Date d2 = new Date(0);//返回1970年1月1日八点的时间,因为是东八区,实际上是1970年1月1日的0点
d2.setTime(1000);//设置毫秒值,改变时间对象(1970年1月1日后的1000毫秒)
Syst.currentTimeMillis();//通过系统类的方法获得当前毫秒值


//时间格式化类 DateFormat 抽象类
DateFormat df1 = DateFormat.getDateInstance();//相当于父类引用指向子类对象,右边的方法返回一个子类 SimpleDateFormat

Date d = new Date();
SimpleDateFormat tm = new SimpleDateFormat();
String strTime = tm.format(d);//返回当前时间的字符串

SimpleDateFormat tm1 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String strTime = tm1.format(dt);
System.out.println(strTime);;

将时间字符串转换成日期对象

String str= "2000年03月09日 09:09:07";
SimpleDateFormat tm2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date d = tm2.parse(str);//会有异常需要处理.将时间字符串转换成日期对象

计算出生多少天

//1.将生日字符串和今天字符串存在String类型的变量中
String birth = "1990年08月08日";
String today = "2088年09月09日";
//2.定义日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
//3.将日期字符串转为日期对象
Date d1 = sdf.parse(birth);
Date d2 = sdf.parse(today);
//4.通过日期对象获得毫秒值
long time = d2.getTime() - d1.getTime();
//5.两个日期相减,求出天数
System.out.println(time/1000/60/60/24);

日历类(Calendar)

Date类中很多方法过时了,由Calendar类的方法替代

Calendar c = Calendar.getInstance();//父类引用指向子类对象,返回
c.get(Calendar.YEAR);    //通过字段获取年
c.get(Calendar.MONTH);    //月份值是0-11
c.get(Calendar.DAY_OF_MONTH);    //月中的第几天
c.get(Calendar.DAY_OF_WEEK);    //周日是第一天,周六是最后一天

将星期存储表中进行查表

//1.返回值类型String\
//2.参数列表 int week

public static String getWeek(int week){
String[] arr = {"","星期日",星期一","星期二","星期三","星期四","星期五","星期六"};
}

c.getWeek(Calendar.DAY_OF_WEEK); 

常见操作:

c.add(Calendar.MONTH,-1);//对指定的字段进行向前减或向后加
c.set(Calendar.YEAR,2000);//修改指定字段
c.set(2000,7,8);//2000年8月8日

判断闰年平年:

//1.键盘录入年Scanner
Scanner sc = new Scanner(System.in);
System.out.println("请输入年份");
//int year = sc.nextInt();
String line = sc.nextLine();
int year = Integer.parseInt(line);//将数字字符串转换成数字,需要异常处理
//判断方法
public static boolean getYear(int year){
    Calendar c = Calendar.getInstance();
    //日期设为那一年的3月1日
    c.set(year,2,1);
    //日期减一天到2月的最后一天
    c.add(Calendar.DAY_OF_MONTH,-1);
    return c.get(Calendar.DAY_OF_MONTH)==29;
}
boolean b = getYear(year);    //返回结果    

Math方法

Math类中全是静态方法,所以构造方法私有了

Math.PI;//3.141592....
Math.sqrt(9);//平方根
Math.cbrt(27);//立方根
Math.abs(-7);//绝对值
Math.ceil(7.7);//向上取整    
Math.floor(-1.1);//向下取整
Math.round(4.6);//四舍五入
Math.min(2,4);//取最小数
Math.max(44,444);//取最大数
Math.pow(2,10);//2的10次方
Math.random();[0-1)随机数    ]

System方法

System是final类,方法都是静态方法.
提供了标准输入(in),标准输出(out),错误输出流(err);

System.gc();
//调用此方法后,不会立即清空内存堆空间,而是加入到计划清空列表中
finalize();//当垃圾回收器确定不存在该对象的更多引用时,对象的垃圾回收期调用该方法.

Systrm.exit(0);//根据惯例,非0的状态码标识异常终止  退出虚拟机
System.currentTimeMillis();//返回1970年1月1日至今的毫秒值
System.arraycopy(from,0,to,0,src.length)

Java的垃圾回收机制;
垃圾:不用的内存对空间
Java会自动开启一个后台线程,此线程进行垃圾的清理,工作原理如下:
计数器法:
当new出的空间有一处引用,计数器+1;当引用结束后,计数器-1
垃圾回收线程,判断计数器的值;当计数器值为0时,将此对象压入栈,进入了计划删除列表.在压入栈的过程中,如果某个对象再次被引用,那么从栈中弹出,逐步清理栈中的对象地址空间.

Ststem.exit(status);

0:jvm正常结束,在程序退出时,会调用gc(),清理在运行过程中占用的内存;
非0:异常结束,没有清理占用的内存

枚举

一一列举
枚举是一种数据类型,在枚举中,声明的值
给枚举值声明对应的int值:

Mon("一", 1), Tue("二", 2);
private EnumTest(String week, int index) {
    this.week = week;
    this.index = index;
}

public static String getWeek(int index) {
    for (EnumTest e : EnumTest.values()
    ) {
        if (index == e.getIndex()) ;
        return e.getWeek();
    }
    return null;
}

Scanner

* hasNextXxx()  判断是否还有下一个输入项,其中Xxx可以是Int,Double等。如果需要判断是否包含下一个字符串，则可以省略Xxx
* nextXxx()  获取下一个输入项。Xxx的含义和上个方法中的Xxx相同,默认情况下，Scanner使用空格，回车等作为分隔符

1)nextInt()键盘录入整数
实际上录入的是数字+\r\n (回车),nextInt方法只获取数字就结束
2)nextLine()键盘录入字符串,可以接受任意类型,遇到\r\n就证明一行结束

同时录入1)2)时字符串会直接通过nextInt()的回车;录入空
解决方法:
1)new两个Scanner;但是浪费空间
2)两个都用nexLtLine(),字符串转数字;