java常用类
java常用类
内部类
1.成员内部类：在一个类的内部定义一个完整的类
例如：外部类public class Body{
内部类class Header{
}
}
内部类可以直接访问外部类的私有成员，而且不破坏封装
内部类可以为外部类提供必要的功能组件，
成员内部类 在类的内部定义，与实例变量，实例方法同级别的类，
在外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
Outer outer = new outer();
Inner inner = new Inter();
一步到位： Inner inner = new Outer().new Inner();
inner.show();
当外部类、内部类存在重命名属性时、会优先访问内部类属性 例如（外部类 .this.属性）
成员内部类不能定义静态成员static、但可以定义静态常量final。
private static final String name ="li";
private static String name ="li"; 错误
打印外部类属性时 内部类属性和外部类的名字相同，要想访问外部类属性Outer.this . name
-
静态内部类
相当于在成员内部类的基础上 加上一个static关键字 也当相当于外部类
不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
package aa; //外部类 public class Outer { private String name = "ww"; //静态内部类;和外部类相同 static class Inner{ private String address="上海"; private String phone="888"; //静态成员 private static String maths = "数学"; public void show() { //调用外部类的属性 //1.先创建外部类对象 Outer outer = new Outer(); System.out.print(outer.name); //调用静态内部类属性方法 System.out.print(address); //调用静态内部类的静态属性 System.out.print(Inner.maths); } } }
只能直接访问外部类的静态成员（实例化成员需实例化外部类对象）
Outer.Inner inner = new Outer.Inner();
Outer.Inner.show();
public class TestOuter { public static void main(String[] args) { Outer.Inner inner= new Outer. Inner(); inner.show(); } }
3.局部内部类 （定义在方法内的）
package com.jun.li.pritact;
//外部类
public class Outer {
private String name ="刘德华";
private int age =55;
public void show() {
// 定义局部变量、局部变量是不能带修饰符的
String address = "上海";
//局部内部类 注意前面不能加任何访问修饰符
class Inner{
//局部内部类的属性
private String phone="19999999";
private String email="999999@.qq.com";
public void show2() {
//访问外部类的属性
System.out.println(Outer.this.name);
System.out.println(Outer.this.age);
System.out.println(address);
}
}
步骤(1) //在此方法内创建内部类对象
Inner inner = new Inner();
inner.show2();
}
}package com.jun.li.pritact;
public class OuterTest {
public static void main(String[] args) {
Outer outer = new Outer();
outer.show();
//想运行show方法中的局部内部类 需只能在其方法内创建对象 上步骤 (1)
}
}
局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，
变量必须修饰为final final String address = "上海";
有限的范围 当前方法内
4.匿名内部类（接口 抽象类用的多）
*没有类名的局部内部类(一切特征都与局部内部类相同)
*继承一个父类或者实现一个接口常使用
Usb usb = new Usb(){
//Usb()可以是父类，抽象类 再重写方法就行
object类
超类、基类、所有类的直接或间接父类，位于继承树的顶层
任何类、没有写extends继承某个类 都默认继承Object类，否则间接继承
Object类的所定义的方法，是所继承对象都具备的
Object类可以存储任何对象 1.作为参数：接收任何对象
2.作为返回值：可以返回任何对象
object类常用方法
1.getClass()方法 返回当前类的实际对象类型
应用：通话常用于判断两个引用中实际存储对象类型是否一致
Class class1=s1.getclass();
Class class2=s2.getclass();
if(class1==class2){
System.out.print("相同类型")
}else{
System.out.print("不相同类型")
}
2.hashCode()方法 返回int类型
public int hashCode（）{}
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());//s1与s2地址不同所以hash值不同
Student s3=s1 //把s1地址赋给s3 所以相同
System.out.println(s3.hashCode());//相同
返回哈希码值、根据对象的地址或字符串或者数字使用hash算法计算出来的int类型的数值
3.toString()方法
eclipse中重写方法 Alt+Enter+s
public String toString(){
return name+":"+age;
}
4.equals()方法 默认实现为（this==obj）。比较两个对象地址是否相同。可覆盖 为比较两个对象的内容是否为相同、通过重写。
重写equals方法 改变equals的判断条件方法
public class Outer {
5.finalize（）方法
当对象被判定为垃圾对象时 ，由JVM自动调用此方法，用于标记垃圾对象，计入回收队列
垃圾对象：指没有有效引用指向此对对象
垃圾回收：由GC销毁对象，释放数据存储空间
自动回收机机制：JVM的内存耗尽，一次性回收所有垃圾对象。
手动回收机制，使用System.gc(); 通知JVM执行垃圾回收。
Student s1 = new Student("aaa",20);//不会被当作垃圾回收
new Student("aaa",20);//会被当做垃圾回收
System.gc();
包装类
基本数据类型 byte、char、short、int、long、float、double、boolean，
基本数据类型都存在栈中，引用类型都在堆中
从而只能通过运算符对基本数据类型操作，
为了让基本数据类型提供更强大的功能所以创造出：基本数据类型所对应的引用数据类型
包装类 是 引用类型默认值为null
| 基本数据类型 | 包装类型 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| boolean | Boolean |
| char | Character |
包装类将对应的基本数据类型包装在一个对象中(对象则变为堆中，就可以使用方法。。。)
类型转换与装箱、拆箱
装箱：把栈(基本类型)拿到堆(引用类型)中，反之拆箱。
装箱：
//基本类型
int n =18;
//使用Integer类创建对象、valueof()方法返回一个 Integer指定的 int值的 Integer实例
1.Integer integer = new Integer(n);//把传入的数字
2.Integer integer1 = Integer.valueof(n);
拆箱：
//intvalue()方法返回int值
Integer integer2 = new Integer(n);
int num2 = integer2.intvalue();
JDk1.5后自动提供装箱拆箱
//自动装箱
int a = 15;
Integer integre1=a;
//自动拆箱
int a2=integer1;
基本类型和字符串之间的转换
//基本类型转换字符串转
int n1 =100;//使用toString（）方法
1.String s1 = n1+"";
2.String s2 = Integer.toString(n1);
//字符串转换成基本类型
` String str ="100";
//使用Integer.parseXXX（）
int n2 = Integer.parseInt(str);
//boolean字符串行式转换成基本类型 "true"都是true 非 true 都是false
String str2 = "false";
boolean b = Boolean.parseBoolean(str2);
Integer缓冲区
//面试题
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
System.out.printin(integer1==integer2);//false
//比的是地址
Integer integer3 = 100;//自动装箱 =Integer integer3 = Integer.valueof(100);
Integer integer4 = 100;//从在Cache[] 数组-128——127中找到 直接给栈内的对象 堆地址相同唯一
System.out.printin(integer3==integer4);//true
Integer integer5 = 200;
Integer integer6 = 200;
System.out.printin(integer5==integer6);//false
//Intrger.valueof(i) i 是有范围的-128——127 超出范围会 new Integer(i); 从而使地址不同
String类
字符串是常量，创建之后不可改变
字符串字面值存储在字符串池(方法区内的)中，可以共享。
实例：
String name ="Hello";//"hello"常量存储在常量池中
name ="zhangsan"; //把zhangsan赋值给name变量，给字符赋值时，并没有修改数据，而是重新开辟空间
String name2 = "zhangsan";
String s ="Hello"; 产生一个对象，字符串池中存储。
String s = new String(“Hello”)；产生两个对象，堆、常量池个存储一个。
//展示字符串的另一个创建方式
String str = new Strinf("java"); //new 在堆中一个对象
String str2 = new Strinf("java");
System.out,printin(str==str2); //false 都在堆中new 所以地址不同
System.out,printin(str.equals(str2));//true 因为这是比的是数据而不是地址
字符串常用的方法
1.public int length() :返回字符串的长度
2.public char charAt(int index) :根据下标获取字符
3.public boolean contains(String str) : 判断当前字符串是否包含str
String name = "java最好";
System.out.printin(name.length()); //6
System.out.printin(name.charAt(name.length()-1)); //好
System.out.printin(name.contains("java")); //true
4.public char[ ] toCharArray( ) :将字符串转换成数组
5.public int indexOf(String str) :查找str首次出现的下标，存在，则返回该下标，不存在，则返回-1.
6.public int lastIndexOf(String str) :查找字符串在当前字符串中最后一次出现的下标索引
String name = "java最好,java真香";
System.out.printin(Arrays.toString(name.toCharArray()));// [j,a,v,a,......]
System.out.printin(name.indexOf("java"));// 0
System.out.printin(name.lastIndexOf("java"));//7
split() 方法中 拆分split（“[ ,]+”）可以表示多个空格或 , 都能拆分
equalsIgnoreCase( )忽略大小写的比较
比较大小 两个字符串依次相同位置且依次往后比较，直至没有则比较长度
案例演示
toUpperCase（ ）可以变为大写
截取 ：subString(int beginIndex )
subString(int beginIndex ，int endIndex)
String增强类 StringBuffer：可变长字符串，运行效率慢，线程安全
(单线程）StringBuilder： 可变长字符串，运行效率快，线程不安全
/**
* StringBuffer和StringBuilser的使用
* 比String 1.效率高
2.节省内存
*/
StringBuffer sb = new StringBuffer();
1.//append（）;追加
sb.append("java世界第一");
System.out.print(sb.toString());
2.//insert（）;添加 可以在某个位置添加
sb.insert(0,"dddddd");
3.// replace(); 可以再指定位置替换
sb.replace(0,5,"DDDDDD");
4.// delete();删除 也可指定位置
sb.delete(0,5);
BigDecimal类
位置：java.math包中
作用：精确计算浮点数。
创建方式： BigDecimal bd = new BigDecimal（“字符串”）；字符串精确
//面试题
double result =(1.4-0.5)/0.9;
//求结果 却为0.0999999999...
BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
//减法 subtract()
BigDecimal r1 = bd1.subtract(bd2);
//加法 add()
BigDecimal r2 = bd1.add(bd2);
//乘法 multiply()
BigDecimal r3 = bd1.multiply(bd2);
//除法 divide() 面试题例题
BigDecimal r4 = new Bigdecimal("1.4")
.subtract(new Bigdecimal("0.5"))
.divide(new Bigdecimal("0.9"));
//除不尽保留几位小数 divide(Bigdecimal bd,int scal（保留几位）,RoudingMode mode（取舍模式 四舍五入等等）)
四舍五入：Bigdecimal.ROUND_HALF_UP
Date类
Date表示特定的瞬间，精确到毫秒，Date类中的大部分方法都已经被Calender类中的方法所取代。
时间单位
1秒=1000毫秒
1毫秒=1000微秒
1微秒= 1000纳秒
toLocalString() 时间格式 xxxx - x - x
Calendar类
Calendar提供了获取或设置各种日历字段的方法
构造方法： protected Calendar() 由于修饰符是protected，所以无法直接创建该对象
1.//创建Calendar对象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocalString());//现在时间2020-10-1
System.out.println(calendar.getTimeInMillis());//获取毫秒值
2.//获取时间信息
年、月、日、时、分、秒
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH); // 月是从0-11开始 所以要加1
int day = calendar.get(Calendar.DAY_OF_MONTH);
int hour = calendar.get(Calendar.HOUR_OF_DAY);// HOUR 12小时、HOUR_OF_DAY24小时
int minute = calendar.get(Calendar.MINUTE);
int second = calendar.get(Calendar.SECOND);
3.//修改时间
Calendar calendar2 = Calendar.getInstance();
calendar2.set(Calendar.DAY_OF_MONTH,5)//修改当日为5
calendar2.add(Calendar.HOUR,+/-1);//增加或减少1个小时
4.//获取最大值最小值
int max = claendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
int min = claendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
SimpleDateFormat类
SimpleDateFormat是一个与语言环境有关的方式来格式化和解析日期的具体类，
进行格式化（日期->文本）、解析（文本->日期） .
常用的时间模式字母
| 字母 | 日期或时间 | 示例 |
|---|---|---|
| y | 年 | 2019 |
| M | 年中月份 | 08 |
| d | 月中天数 | 10 |
| H | 一天中小时数 | 24 |
| m | 分钟 | 25 |
| s | 秒 | 60 |
| S | 毫秒 | 666 |
1.//创建SimpleDateFormat对象 y年M月s天H时m分s秒
SimpleDateFormat sdf =new SimpleDateFormat(patter);//pattern表示参数
↓
↓
SimpleDateFormat sdf =new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
2.//创建Date
Date date = new Date();
//格式化date，把日期转成字符串
String str = sdf.format(date);
System.out.print(str);
//解析，把字符串转成日期
Date date = sdf.parse("1990/5/1")
System类
System是系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的
| 方法名 | 说明 |
|---|---|
| static void arraycopy(......) | 复制数组 |
| static long currentTimeMillis（）; | 获取当前系统时间，返回毫秒值 |
| static void gc（）； | 建议JVM赶快启动垃圾回收器回收垃圾 |
| static void exit (int status); | 退出JVM，如果参数是0表示正常退出JVM，非0表示异常退出JVM |
1.
//src :源数组
//srcPos:从哪个位置开始复制
//dest ：目标数组
//destPos：目标位置
public class Test1 {
public static void main(String[] args) {
int[] arr1 = {2,5,6,4,5};
int [] arr2 = new int[10];
//System.arraycopy(src, srcPos, dest, destPos, length);
System.arraycopy(arr1, 0, arr2, 1, 2);
for (int i = 0; i < arr2.length; i++) {
System.out.print(arr2[i]+",");
}
}
}
2.
// System.out.println(System.currentTimeMillis());
// 也可以用来计时
long start = System.currentTimeMIllis();
long end = System.currentTimeMIllis();
3.
//System.gc();垃圾回收
4.System.exit(0)
#
