常用类
Object类
- 概述
- java.lang.Object类,是java语言的根类,即所有类的父类,他所描述的所有方法,子类都可以使用。在对象实例化的时候,最终找到的父类Object
- 如果一个类没有特别指明父类,那么默认认为继承Object类
toString方法
- 一个类是否重写了toString方法,直接打印这个对象即可,没有重写会打印堆地址值,重写后会打印属性
package object;
import java.util.Random;
import java.util.Scanner;
/*
java.lang.Object
Object类是所有类的根类,所有类都直接或间接继承他
*/
public class ToString {
public static void main(String[] args) {
//Person类默认继承了Object类,所以可以直接使用ToString方法
// 返回该对象的字符串表示
Person p = new Person("zhangsan", 18);
String s = p.toString();
System.out.println(s);
//打印对象在堆中的地址值,object.Person@1b6d3586
//直接打印对象的名字,就是调用toString方法
//直接打印p,就相当于打印p.toString
System.out.println(p);
//看一个类是否重写了toString方法,直接打印这个对象即可,没有重写会打印地址值,重写后会打印属性
Random random = new Random();
System.out.println(random);//java.util.Random@4554617c,没有被重写
Scanner scanner = new Scanner(System.in);
System.out.println(scanner);//java.util.Scanner[delimiters=\p{javaWhitespace}+][position=0][match valid=false][need input=false][source closed=false][skipped=false][group separator=\,][decimal separator=\.][positive prefix=][negative prefix=\Q-\E][positive suffix=][negative suffix=][NaN string=\Q�\E][infinity string=\Q∞\E]
//已经被重写了
}
}
/*
package object;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
/*
直接打印对象的堆地址值无意义,我们重写他完成一些其他功能
打印对象的属性 name age
*/
/*
@Override
public String toString() {
//return "ads";
return "{name=" +name+" "+"age="+age+"}";
}
*/
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
*/
equals方法
- 调用成员方法equals并指定参数为另一个对象,可以判断领个对象是否相同。只要不是同一个对象,结果必为false(布尔值)
1
package object;
public class Equals {
public static void main(String[] args) {
/*
public boolean equals(Object obj) {
return (this == obj);
}
this,那个对象调用的this,则this就代表那个对象
obj代表传递的参数p2
this == obj ------------> p1==p2
参数obj可以传递任意的对象
==比较运算符
比较基本类型时,比较的是值
比较引用类型时,比较的是地址值
*/
Person p1 = new Person("zhangsan", 18);
Person p2 = new Person("lisi", 18);
//打印p1与p2的地址
System.out.println("p1"+p1);
System.out.println("p2"+p2);
boolean a = p1.equals(p2);
System.out.println(a);
System.out.println("===========================");
//把p2的地址值赋值给p1
p1=p2;
System.out.println("p1"+p1);
System.out.println("p2"+p2);
boolean b = p1.equals(p2);
System.out.println(b);
}
}
2
package object;
import java.util.Objects;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
/*
Object类的equals方法比较的是对象的地址值,我们重写他,让他比较对象属性的值(name age)
问题
其中隐含着一个多态(父类对象new子类对象)
多态的弊端无法,无法使用子类的特有属性,因为父类中可能不包含这些属性
解决,可以使用向下转型(强转)把Object类转换为,Person类
*/
/* @Override
public boolean equals(Object obj) {
//判断传递的参数是否为自己本身,如果是直接返回true,提高程序效率
if(obj==this){
return true;
}
//判断传递的参数是否为null,如果是直接返回false,提高程序效率
if(obj==null){
return false;
}
//不是同一类型不能强转,因此我们需要先判断是否为同一类型
if(obj instanceof Person){
*//* Person p3=(Person) obj;
boolean a=this.name==p3.name&&this.age==p3.age;
return a;*//*
//使用向下转型把Object转换为Person
Person p3=(Person)obj;
//比较两个对象,一个是this.p2 一个是obj(p3)
return this.name==p3.name&&this.age==p3.age;
}
//不是Person类型直接返回false
return false;
//可以使用官方的重写方法,Alt+Insert--->equal and hashcode------>
//下面为方法
}*/
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
3
package object;
public class Equals {
public static void main(String[] args) {
/*
public boolean equals(Object obj) {
return (this == obj);
}
this,那个对象调用的this,则this就代表那个对象
obj代表传递的参数p2
this == obj ------------> p1==p2
参数obj可以传递任意的对象
==比较运算符
比较基本类型时,比较的是值
比较引用类型时,比较的是地址值
*/
Person p1 = new Person("zhangsan", 18);
Person p2 = new Person("zhangsan", 18);
boolean a = p1.equals(p2);
System.out.println(a);
/* //打印p1与p2的地址
System.out.println("p1"+p1);
System.out.println("p2"+p2);
boolean a = p1.equals(p2);
System.out.println(a);
System.out.println("===========================");
//把p2的地址值赋值给p1
p1=p2;
System.out.println("p1"+p1);
System.out.println("p2"+p2);
boolean b = p1.equals(p2);
System.out.println(b);*/
}
}
Objects类
在java的JDK7中添加了,Objects工具类,它提供一些方法来操作对象,它由一些静态的方法组成,这些方法是null-save(空指针安全的)或者null-tolerant(能够容忍空指针),用于继续算对象的hashcode,返回对象的字符串表示形式,比较两个对象
比较两个对象时,Object的equals方法容易抛出空指针异常,Objects中的equals方法优化了这个问题
package object;
import java.util.Objects;
public class DemoObjects {
public static void main(String[] args) {
String s1="abc";
String s2="aBc";
boolean p1 = s1.equals(s2);
System.out.println(p1);
System.out.println("=========================");
s1=null;
//boolean p2 = s1.equals(s2);// NullPointerException(出现空指针异常),null不能调用方法
/*
使用Objects里面的equal方法,比较,
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
*/
boolean p2=Objects.equals(s1,s2);
System.out.println(p2);
}
}
日期时间类
Date类
java.util.Date类,表示特定的瞬间,精确到毫秒
date拥有多个构造函数,只是部分已经过时,但是其中为过时的构造函数可以把毫秒转化为日期对象
-
public Date();,分配Data对象并初始化对象,以表示分配他的时间,精确到毫秒
-
public Date(long data);,分配Data对象并初始化对象,以表示分配自标准基准时间(历元,epoch),即1970.1.1-00:00:00(GMT)以来的毫秒数
-
由于我们是东八区因此我们是,1970.1.1-08:00:00开始计时
-
毫秒值的作用,可以对时间日期进行计算,然后转化为日期,1天=146060秒=86400秒=86400000毫秒
总的来说,使用无参构造,可以设置当前系统时间的毫秒时刻。使用long类型构造参数,可以自动以毫秒时刻
1
package date;
/*
毫秒值的作用,可以对时间日期进行计算
可以把日期转换为毫秒,进行计算,计算完毕,再把毫秒转换为日期
注意,中国是东八区,需要加八个小时
把日期转化为毫秒,就是把现在的日期与历元进行比较(1577672377905L)
把毫秒转化为日期,
1天=24*60*60秒=86400秒=86400000毫秒
*/
public class DemoDate {
public static void main(String[] args) {
System.out.println(System.currentTimeMillis());//获取当前系统的毫秒值System.currentTimeMillis()
}
}
2
package date;
import java.util.Date;
public class DemoDate02 {
public static void main(String[] args) {
demo01();
System.out.println("===================================");
demo02();
System.out.println("===================================");
demo03();
}
/*
long getTime 把日期转换为毫秒相当于System.currentTimeMillis()
返回在历元至现在Date对象的的毫秒值
*/
private static void demo03() {
Date date02 = new Date();
long time02 = date02.getTime();
System.out.println(time02);
}
/*
Date类的带参数构造方法
传递毫秒值,把毫秒制转换为日期
Date(long date)
*/
private static void demo02() {
Date date01 = new Date(1577672377905L);
System.out.println(date01);
}
//Date类的空参数构造方法
//Date()用于获取当前系统的日期和时间
private static void demo01() {
Date date = new Date();
System.out.println(date);//Mon Dec 30 10:28:13 CST 2019
}
}
DateFormat类
java.text.DateFormat,是时间日期格式化类子类的抽象类,我们可以通过这个类帮我们完成日期和文本之间的转换,也就是可以在Date对象和String对象之间转化
- 格式化,按照指定格式,从Date对象转化为String对象
- 解析,按照指定格式,从String对象转化为Date对象
构造方法
由于DateFormat类是抽象类,不能直接使用,所以需要常用子类java.text.SimpleDateFormat,这个类需要一个格式来指定格式化、解析的标准
public SimpleDateFormat(String pattern),pattern代表时间日期格式
package date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
DemoForMat是时间、日期的抽象化子类
作用
格式化 日期----->文本 解析,文本----->日期
成员方法
String format(Date date) 按照指定模式,把Date日期格式化为符合的模式的字符串
Date parse(String source) 按照指定模式,把字符串D格式化为符合的模式的ate日期
DateForMat是一个抽象类,无法直接创建对象使用,可以使用DateForMat类的子类SimpleDateFormat
java.text.SimpleDateFormat
public class SimpleDateFormat extends DateFormat
SimpleDateFormat(String pattern)
使用给定模式 SimpleDateFormat并使用默认的 FORMAT语言环境的默认日期格式符号。
参数
String pattern,指定的格式,区分大小写
y 年
M 月
d 日
H 时
m 分
s 秒
写出对应模式,就会显示为对应模式
yyyy-MM-dd HH:mm:ss
注意
模式中的字母不能改,连接模式的符号可以改
*/
public class DemoForMat {
public static void main(String[] args) {
//格式化
demo01();
System.out.println("=========================================");
//解析
demo02();
}
private static void demo02() {
/*
Date parse(String source) 按照指定模式,把字符串D格式化为符合的模式的ate日期
步骤
1.创建SimpleDateFormat对象,构造方法中指定模式
2.使用SimpleDateFormat对象中的方法parse,把文本转化为日期
注意
public Object parseObject(String source) throws ParseException
parse申明了一个异常叫做ParseException,解析异常,字符串和我们的构造方法的模式不一样,就抛出异常
*/
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date date = new Date();
String a=simpleDateFormat.format(date);
try {
System.out.println(simpleDateFormat.parse(a));
} catch (ParseException e) {
e.printStackTrace();
}
}
private static void demo01() {
/*
使用DateForMat中的format方法,把文本格式化
1.创建SimpleDateFormat对象,构造方法中指定模式
2.使用SimpleDateFormat对象中的方法format,按照构造方法中的指定模式,把Date日期格式转化为符合模式的文本
*/
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
System.out.println(simpleDateFormat.format(System.currentTimeMillis()));
System.out.println("=========================================");
Date date = new Date();
System.out.println(date);
String s=simpleDat
eFormat.format(date);
System.out.println(s);
}
}
练习
使用时间相关api,计算一个人出生了多少天
package date;
/*
使用时间相关api,计算一个人出生了多少天
分析
1.用Scanner的next取日期字符串
2.使用parse把字符串转换为Date格式
3.获取历元到当前毫秒值
4.历元到你出生的毫秒值
5.两值相减,转化为天数
*/
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
public class Demo03 {
public static void main(String[] args) throws ParseException {
System.out.println("输入你的出生日期格式,年.月.日");
Scanner scanner = new Scanner(System.in);
String day=scanner.next();
Date date = new Date();
long time1 = date.getTime();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd");
Date parse = simpleDateFormat.parse(day);
System.out.println(parse);
long time2 = parse.getTime();
long time=time1-time2;
System.out.println(time);
System.out.println("你出生了"+time/(24*60*60*1000)+"天");
}
}
Calendar(日历类)
java.text.Calendar,是日历类。在Date类后出现,替换了很多Date的方法。该类将所有能用到的类,封装为静态成员变量,方便获取,日历类方便获取各个时间属性。
- 抽象类
- 常用方法
- public int get(int field);,返回给定日历字段的值
- public void set (int field int value);,金给定的日历字段设置为给定的值
- public abstract void add (int field int amount);,根局日历规则,为给定日历添加或减去给定时间量
- public Date getTime();,返回一个Calendar时间值(从历元到现在的的毫秒偏移量)的Date对象
字段值 | 含义 |
---|---|
YEAR | 年 |
MONTH | 月 |
DAY_OF_MONTH | 月中的天(几号) |
package calendar;
/*
java.text.Calendar
是抽象类,里面提供了很多操作日历字段的方法(YEAR , MONTH , DAY_OF_MONTH , HOUR )
Calendar无法直接创建方法使用,里面有一个静态方法,getInstance(),该方法返回了Calendar类的子类对象
static Calendar getInstance(TimeZone zone, Locale aLocale) 获取具有指定时区和区域设置的日历。
*/
import java.util.Calendar;
public class Demo01 {
public static void main(String[] args) {
Calendar instance = Calendar.getInstance();//多态
System.out.println(instance);
}
}
package calendar;
import java.util.Calendar;
import java.util.Date;
/*
public int get(int field);,返回给定日历字段的值
public void set (int field int value);,金给定的日历字段设置为给定的值
public abstract void add (int field int amount);,根局日历规则,为给定日历添加或减去给定时间量
public Date getTime();,返回一个Calendar时间值(从历元到现在的的毫秒偏移量)的Date对象
参数
int field 日历类的字段,可以使用calendar的静态成员获取,
*/
public class Demo02 {
public static void main(String[] args) {
demo01();
System.out.println("========================");
demo02();
System.out.println("========================");
demo03();
System.out.println("========================");
demo04();
}
/*
public Date getTime();,返回一个Calendar时间值(从历元到现在的的毫秒偏移量)的Date对象
把日历对象转换为日期对象
*/
private static void demo04() {
Calendar instance = Calendar.getInstance();
Date time = instance.getTime();
System.out.println(time);
}
/*
public abstract void add (int field int amount);,根局日历规则,为给定日历添加或减去给定时间量
*/
private static void demo03() {
Calendar instance = Calendar.getInstance();
int i = instance.get(Calendar.YEAR);
System.out.println(i);
instance.add(Calendar.YEAR,2);
int i1 = instance.get(Calendar.YEAR);
System.out.println(i1);
int i3 = instance.get(Calendar.MONTH);
System.out.println(i3);
instance.add(Calendar.MONTH,-2);
int i2 = instance.get(Calendar.MONTH);
System.out.println(i2);
}
/*
public void set (int field int value);,金给定的日历字段设置为给定的值
*/
private static void demo02() {
Calendar instance = Calendar.getInstance();
instance.set(Calendar.YEAR,2222);
int i = instance.get(Calendar.YEAR);
System.out.println(i);
//同时设置年月日
instance.set(3333,2,21);//set方法重载
}
/*
public int get(int field);,返回给定日历字段的值
*/
private static void demo01() {
//使用getIntance方法获取calendar对象
Calendar instance = Calendar.getInstance();
int i = instance.get(Calendar.YEAR);
System.out.println(i+"年");
int i1 = instance.get(Calendar.MONTH);
System.out.println(i1+1+"月");//西方的月份是0----7
int i2 = instance.get(Calendar.DAY_OF_MONTH);
System.out.println(i2+"号");
int i4 = instance.get(Calendar.DAY_OF_WEEK_IN_MONTH);
System.out.println("这个月的第"+i4+"个周");
int i3 = instance.get(Calendar.DAY_OF_WEEK);//星期
System.out.println("这个周的第"+i3+"天");
}
}
System类
java.lang.System,里面包含了大量静态方法。可以获取与系统相关的操作、系统的信息。
常用方法
- static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)` 将指定源数组中的数组从指定位置复制到目标数组的指定位置。
- static long currentTimeMillis()` 返回当前时间(以毫秒为单位)。
package system;
import java.sql.SQLOutput;
import java.util.Scanner;
/*
- static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)` 将指定源数组中的数组从指定位置复制到目标数组的指定位置。
- static long currentTimeMillis()` 返回当前时间(以毫秒为单位)。
*/
public class Demo01 {
public static void main(String[] args) {
demo01();
System.out.println("=================");
demo02();//数组复制
}
/*
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)`
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目的地数据中的起始位置。
length - 要复制的数组元素的数量。
*/
private static void demo02() {
int[] a={1,2,3,4,5,6,7,8,9};
int[] b={1,11,111,1111,11111,111111};
System.arraycopy(b,2,a,3,2);
for (int i : a) {
System.out.println(i);
}
}
/*
static long currentTimeMillis()` 返回当前时间(以毫秒为单位)。
计算运算耗费时间
*/
private static void demo01() {
//打印1----99999所用时间
long a=System.currentTimeMillis();
for (int i = 0; i <= 9999; i++) {
System.out.println(i);
}
long a1=System.currentTimeMillis();
System.out.println(a1-a);
}
}
StringBuilder
- String类
- 由于String类的对象内容不可改变。所以每当字符串拼接时总是在内存中建立新的对象。
- 字符串的底层是一个被final修饰的数组,是一个常量
例,String s=“a”+“b”+“c”;,内存中会出现5个字符串,“a”、“b”、“c”、“ab”、“abc”
- StringBuilder
- 字符串缓冲区,提高效率(可以看成一个字符串可以变化的数组)
- 底层是一个数组,但没有被final修饰,可变长
- StringBuilder的初始容量是16bit,超出了自动增加16
- StringBuilder在组合是一个数组,占用空间少
1
package stringbuild;
/*
java.lang.StringBuilder 字符串缓冲区,可以提高字符串效率
构造方法
StringBuilder() 构造一个没有字符的字符串构建器,初始容量为16个字符。
StringBuilder(String str) 构造一个初始化为指定字符串内容的字符串构建器。
*/
public class Demo01 {
public static void main(String[] args) {
StringBuilder stringBuilder = new StringBuilder();
System.out.println("gsyugyu"+stringBuilder);
StringBuilder huiheduihdui = new StringBuilder("huiheduihdui");
System.out.println("ghuihuiwyiuwh"+huiheduihdui);
}
}
2
package stringbuild;
/*
StringBuilder常用方法
append添加任意类型的字符串形式,返回当前对象本身
*/
public class Demo02 {
public static void main(String[] args) {
//创建StringBuild对象
StringBuilder stringBuilder = new StringBuilder();
//使用append方法添加数据
//append返回的是this,this==stringBuilder
StringBuilder hsuhui = stringBuilder.append("hsuhui");
System.out.println(stringBuilder==hsuhui);//引用类型比较地址
stringBuilder.append(1111);
stringBuilder.append("juifhuifjiuj");
stringBuilder.append(false);
stringBuilder.append(10.25);
System.out.println(stringBuilder);
//链式编程,方法的返回值是一个对象可以继续调用
stringBuilder.append(1111).append("juifhuifjiuj").append(false).append(10.25);
System.out.println(stringBuilder);
}
}
3
package stringbuild;
/*
StringBuilder和String相互转化
String——>StringBuilder 可以使用StringBuilder的构造方法
StringBuilder(String str) 构造一个初始化为指定字符串内容的字符串构建器。
StringBuilder---->String 使用 StringBuilder 的toString方法
*/
public class Demo03 {
public static void main(String[] args) {
String a="hello";
StringBuilder stringBuilder = new StringBuilder(a);
stringBuilder.append(" world");
System.out.println(a+stringBuilder);
String s = stringBuilder.toString();
System.out.println(s);
}
}
Random
package random;
import java.util.Random;
/*
Random类,用来产生随机数字
使用
1.导包
2.创建
Random r=new Random(); 小括号留空即可
3.使用
获取一个随机的int类型数字 r.nextInt(); 范围为int所有范围,有正负
获取一个随机的int类型数字 r.nextInt(3); 参数代表范围,左闭右开区间[0,3)
*/
public class Demo01 {
public static void main(String[] args) {
Random random = new Random();
System.out.println(random.nextInt());
System.out.println(random.nextInt(6));
}
}
2
package random;
import java.util.Random;
import java.util.Scanner;
/*
练习,猜数字游戏 二分法查找
*/
public class Text {
public static void main(String[] args) {
Random random = new Random();
int a=1+random.nextInt(100);
System.out.println("随机数是"+a);
System.out.println("===+++++开始查找+++++===");
Scanner scanner = new Scanner(System.in);
int j=0;
while (true){
j++;
int i = scanner.nextInt();
if(a==i){
System.out.println("猜对了,你猜了"+j+"次");
break;
}
if(i>a){
System.out.println("猜大了");
}else{
System.out.println("猜小了");
}
}
scanner.close();
}
}
Arrays工具类
package arrays;
import java.util.Arrays;
/*
java.util.Arrays,是一个与数组相关的工具类,里面提供了大量静态方法,用来实现数组常见操作
public static String toString(数组) 按照默认格式,将参数数组变成字符串
public static void sort(数组) 数组按升序排序
备注
1.如果是数值,按照数字升序排列
2.如果是字母按照字母升序排列
3.如果是自定义类型,那么自定义类需要comparable或者comparator接口的支持
*/
public class Demo01 {
public static void main(String[] args) {
int[] a={1,5,3,6,4,8,9,7};
String s= Arrays.toString(a);
System.out.println(s);
Arrays.sort(a);
String s1=Arrays.toString(a);
System.out.println(s1);
String[] b={"b","d","c","a"};
System.out.println(Arrays.toString(b));
Arrays.sort(b);
System.out.println(Arrays.toString(b));
}
}
Math类
package math;
/*
java.lang.Math,数学相关的工具类,里面有大量与数学相关的静态方法,完成与数学相关的运算
static double abs(double a) 返回值为 double绝对值。
static double ceil(double a) 向上取整
static double floor(double a) 向下取整
static long round(double a) 四舍五入
*/
/*
计算绝对值-10.5到4.1之间,绝对值大于6.绝对值小于2的有几个数
*/
public class Demo01 {
public static void main(String[] args) {
double a=-10.5;
int z=0;
int y=0;
for ( ; a < 4.1; a+=1) {
double i=a;
a=Math.ceil(a);
a=Math.abs(a);
if(a<0){
if(a>6){
z++;
}else if(a<2){
y++;
}
}
if(a>0){
if(a>6){
z++;
}else if(a<2){
y++;
}
}
a=i;
}
System.out.println("大于6的有"+z+"个"+"小于2的有"+y+"个");
}
}
包装类
java提供两个类型系统,基本类型和引用类型。使用基本了类型在于效率,然而很多时候,会对象使用。因为对象可以做更多的功能。若果我妈们想要基本类型像对象一样使用,就可以使用基本类型对应的包装类。
基本类型 | 对应包装类(java.lang包) |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Character |
boolean | Boolean |
- 基本数据类型使用起来很方便,但是没有对应的方法来操作这些基本数据类型,可以使用一个类把数据类型装起来,在类中定义一些方法,这个类叫基本类。我们可以使用类中的方法来操作这些基本类型的数据。
装箱与拆箱
基本类型与对应包装类转换的过程称为装箱与拆箱。
- 装箱,从基本类型转换为对应的包装类对象
- 拆箱,从包装类对象转换为对应的基本类型
//基本类型---->包装对象
Integer i=new Integer(4); //使用构造函数
Integer ii=Integer.valueOf(4); //使用包装类的valuaOf方法
//包装对象---->基本类型
int n=i.intvalue();
package classtext01;
/*
- 装箱,从基本类型转换为对应的包装类对象
构造方法
Integer(int value) 构造一个新分配的 Integer对象,该对象表示指定的 int值。
Integer(String s) 构造一个新分配 Integer对象,表示 int由指示值 String参数。
传递的字符串必须是基本类型的字符串,不然会抛出异常 例"1000"
静态方法
static Integer valueOf(String s) 返回一个 Integer对象,保存指定的值为 String 。
static Integer valueOf( int i) 返回一个 Integer对象,保存从指定的String中 String的值,当用第二个参数给出的基数进行解析时。
- 拆箱,从包装类对象转换为对应的基本类型
成员方法
int intValue() 将 Integer的值作为 int 。
*/
public class Demo01 {
public static void main(String[] args) {
Integer integer = new Integer(1);
System.out.println(integer);//1 重写了toString方法
Integer integer1 = new Integer("1");
System.out.println(integer1);
Integer integer2 = Integer.valueOf(1);
System.out.println(integer2);
Integer integer3 = Integer.valueOf("1");
//Integer integer3 = Integer.valueOf("a");//.NumberFormatException(数字格式化异常)
System.out.println(integer3);
//拆箱
int i=integer.intValue();
System.out.println(i);
}
}
自动拆箱装箱
package classtext01;
/*
自动拆箱与自动装箱,基本类型与包装类型自动进行转换
JDK1.5之后的新特性
*/
public class Demo02 {
public static void main(String[] args) {
//自动装箱 把int类型的赋值给包装类
Integer i=1;// Integer i=new Integer(1);
//自动拆箱 i是包装类无法直接进行运算,但是可以自动转换为基本类型进行运算
i=i+2;// int i=intValue(i)+2;
}
}
基本类型与字符串之间的转换
package classtext01;
/*
基本类型与字符串类型之间的转化
基本类型---->字符串
1.基本类型的值+""(空字符串)
2.包装类的静态方法toString(参数)
3.String类的静态方法valueOf(方法)
字符串---->基本类型
使用包装类的静态方法parseXXX("数值类型的字符串")
Integer类 static int parseInt(String s);
Double类 static doule parseDouble(String s);
*/
public class Demo03 {
public static void main(String[] args) {
int i=100;
String s=i+"";
System.out.println(s+222);
String s1=Integer.toString(100);
System.out.println(s1+222);
String s2 = String.valueOf(100);
System.out.println(s2+222);
int i1 = Integer.parseInt(s2);
System.out.println(i1-1);
}
}
File类
概述
java.io.File,文件和目录路径名的抽象表示,主要用于文件和目录的创建,查找、删除等操作。
package filetext01;
import java.io.File;
/*
java.io.File
文件和目录路径名的抽象表示
java把电脑中的文件和文件夹封装为一个File类,我们可以使用File类对文件和文件夹进行操作
我们可以使用File类的方法
创建文件、文件夹
删除文件、文件夹
获取文件、文件夹
判断文件、文件夹是否存在
对文件夹遍历
获取文件大小
File类是一个与系统无关的类,任何操作系统都可以使用其中的方法
重点记忆
file 文件
directory 文件夹
path 路径
*/
public class Demo01 {
public static void main(String[] args) {
/*
static String pathSeparator 与系统相关的路径分隔符字符,为方便起见,表示为字符串。
static char pathSeparatorChar 与系统相关的路径分隔符。
static String separator 与系统相关的默认名称 - 分隔符字符,以方便的方式表示为字符串。
static char separatorChar 与系统相关的默认名称分隔符。
操作路径不要写死
windows "F:\makedown"
Linux "F:/makedown"
通用 "F:"+File.separator+"makedown"
*/
String pathSeparator = File.pathSeparator;
System.out.println(pathSeparator); //路径分隔符 windows ;(分号) Linux :(冒号)
String separator = File.separator;
System.out.println(separator);//文件名称分隔符 windows\(反斜杠) Linux /(正斜杠)
}
}
相对路径与绝对路径
package filetext01;
import java.io.File;
/*
路径
绝对路径,是一个完整的路径
以盘符开始的路径 F:\makedown\day05.md
相对路径,是一个简化的路径
相对于当前项目的根目录(F:\makedown\day05.md)
如果使用当前项目的根目录,路径可以简化书写F:\makedownday05.md简化为day05.md(可以省略项目的根目录)
注意
1.路径不区分大小写
2.路径中的分隔符在windows中为,反斜杠(\),但是\为转义字符,所以要写两次
*/
public class Demo02 {
public static void main(String[] args) {
/*
File类的构造方法
*/
show01();
show02("c:","a.txt");
show03();
}
/*
File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的 File实例。
参数,把路径分成了两部分
String parent,父路径
String child,子路径
好处
父路径和子路径可以单独书写,使用起来非常灵活,子路径父路径都可以变化
父路径是File类型,可以使用File方法对路径进行一些操作,在使用路径创建对象
*/
private static void show03() {
File parent = new File("c:");
File file = new File(parent,"hello");
System.out.println(file);
}
/*
File(String parent, String child) 从父路径名字符串和子路径名字符串创建新的 File实例。
参数,把路径分成了两部分
String parent,父路径
String child,子路径
好处
父路径和子路径可以单独书写,使用起来非常灵活,子路径父路径都可以变化
*/
private static void show02(String parent, String child) {
File f3 = new File(parent,child);
System.out.println(f3);
}
/*
File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
参数
pathname路径名
路径可以是以文件结尾,也可以是文件夹结尾
路径可以是相对路径也可以是绝对路径
路径可以是存在的也可以是不存在的
创建File对象,只是把字符串封装为File对象,不考虑路径的真假情况
*/
private static void show01() {
File f1=new File("F:\\makedown\\a.txt");
System.out.println(f1);//重写了toString方法
File f2 = new File("F:\\makedown");
System.out.println(f2);
File f3 = new File("b.txt");//相对路径
System.out.println(f3);
}
}
常用方法
package filetext01;
import java.io.File;
/*
public String getName() 返回由此抽象路径名表示的文件或目录的名称。
public String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。
public String getPath() 将此抽象路径名转换为路径名字符串。
public long length() 返回由此抽象路径名表示的文件的长度。 如果此路径名表示目录,则返回值未指定。
*/
public class Demo03 {
public static void main(String[] args) {
show01();
show02();
show03();
show04();
}
/*
public long length() 返回由此抽象路径名表示的文件的长度。 如果此路径名表示目录,则返回值未指定。
获取得是构造方法指定文件的大小,以字节为单位
注意
1.文件夹没有大小概念,不能获取文件夹大小
2.如果构造方法中的文件不存在,返回0
*/
private static void show04() {
File f1 = new File("E:\\图片\\000000000.png");
long length = f1.length();
System.out.println(length);
}
/*
public String getName() 返回由此抽象路径名表示的文件或目录的名称。
获取的就是构造方法的传递路径的结尾部分(文件或文件夹)
*/
private static void show03() {
File f1 = new File("F:\\java-code\\com.a\\a.txt");
String name = f1.getName();
System.out.println(name);
File f2 = new File("F:\\java-code\\com.a");
String name1 = f2.getName();
System.out.println(name1);
}
/*
public String getPath() 将此抽象路径名转换为路径名字符串。
相对的就返回相对的,绝对的就返回绝对的
toString方法调用的就是getPath方法
*/
private static void show02() {
File f1 = new File("F:\\java-code\\com.a\\a.txt");
File f2 = new File("a.txt");
String path = f1.getPath();
System.out.println(path);
String path1 = f2.getPath();
System.out.println(path1);
}
/*
public String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。
获取构造方法中传输的路径
无论路径是绝对的还是相对的getAbsolutePath()方法返回的都是绝对的
*/
private static void show01() {
//根目录是F:\java-code\com.a
File f1 = new File("F:\\java-code\\com.a\\a.txt");
String absolutePath1 = f1.getAbsolutePath();
System.out.println(absolutePath1);
File f2 = new File("a.txt");
String absolutePath2 = f2.getAbsolutePath();
System.out.println(absolutePath2);
}
}
File类判断功能方法
package filetext01;
import java.io.File;
/*
Filer判断功能方法
public boolean exists() 测试此抽象路径名表示的文件或目录是否存在。
public boolean isDirectory() 测试此抽象路径名表示的文件是否为目录。
public boolean isFile() 测试此抽象路径名表示的文件是否为普通文件。
*/
public class Demo04 {
public static void main(String[] args) {
show01();
show02();
}
/*
public boolean isDirectory() 测试此抽象路径名表示的文件是否为目录。
判断构造方法中的路径是否以文件结尾
是,true
否,false
public boolean isFile() 测试此抽象路径名表示的文件是否为普通文件。
判断构造方法中的路径是否以文件结尾
是,true
否,false
注意
硬盘中只有文件夹和文件,两个方法是互斥的
这两个方法的路径都必须存在,不然返回false
*/
private static void show02() {
File f2 = new File("E:\\图片\\000000000.png");
if(f2.exists()) {
//判断一下文件夹是否存在
System.out.println(f2.isFile());
System.out.println(f2.isDirectory());
}
File f3 = new File("E:\\图片");
if(f3.exists()) {
//判断一下文件夹是否存在
System.out.println(f3.isFile());
System.out.println(f3.isDirectory());
}
}
/*
public boolean exists() 测试此抽象路径名表示的文件或目录是否存在。
判断构造方法中的路径是否存在
存在,true
不存在,false
*/
private static void show01() {
File f1 = new File("E:\\图片\\000000000.png");
System.out.println(f1.exists());//true
File f2 = new File("E:\\图片\\00000.png");
System.out.println(f2.exists());//false
File f3 = new File("com.a.iml");
System.out.println(f3.exists());//true
}
}
File类创建删除功能方法
package filetext01;
import java.io.File;
import java.io.IOException;
/*
File类创建删除文件夹或文件
public boolean createNewFile() 当且仅当具有该名称的文件尚不存在时,创建一个由该抽象路径名命名的新的空文件。
public boolean delete() 删除由此抽象路径名表示的文件或目录。
public boolean mkdir() 创建由此抽象路径名命名的目录。
public boolean mkdirs() 创建由此抽象路径名命名的目录,多级文件夹
*/
public class Demo05 {
public static void main(String[] args) throws IOException {
show01();
show02();
show03();
}
/*
public boolean delete() 删除由此抽象路径名表示的文件或目录。
此方法可以删除构造路径中的文件或文件夹
返回值 布尔
true,文件或文件夹删除成功,返回true
false,文件夹中有文件不会删除返回false,构造方法中的路径不存在也返回false
注意
delete方法是直接在硬盘删除,不经过回收站,删除请谨慎
*/
private static void show03() {
File f1 = new File("F:\\java-code\\com.a\\qwe");
System.out.println(f1.delete());
}
/*
public boolean mkdir() 创建由此抽象路径名命名的目录。单级空文件夹
public boolean mkdirs() 创建由此抽象路径名命名的目录,多级空文件夹也可单级空
返回值 布尔
true,文件夹不存在,创建文件夹,返回true
false,文件夹存在,不创见文件夹,返回false 构造方法中的路径不存在也返回false
注意
1.此方法只能创建文件夹,不能创建文件
*/
private static void show02() {
File f1 = new File("F:\\java-code\\com.a\\qwe");
System.out.println(f1.mkdir());
File f2 = new File("F:\\java-code\\com.a\\111\\222\\333");
System.out.println(f2.mkdirs());
}
/*
public boolean createNewFile() 当且仅当具有该名称的文件尚不存在时,创建一个由该抽象路径名命名的新的空文件。
创建文件的路径在构造方法中给出
返回值 布尔
true,文件不存在,创建文件,返回true
false,文件存在,不创见文件,返回false
注意
1.此方法只能创建文件,不能创建文件夹
2.创建文件的路径必须存在,不然会抛出异常
public boolean createNewFile() throws IOException
我们使用这个方法就需要处理这个异常,要么throws要么try catch
*/
private static void show01() throws IOException {
File f1 = new File("F:\\java-code\\com.a\\a.txt");
boolean newFile = f1.createNewFile();
System.out.println(newFile);
//相对路径
File f2 = new File("1.txt");
System.out.println(f2.createNewFile());
}
}
File类遍历目录功能
package filetext01;
import java.io.File;
/*
public String[] list(FilenameFilter filter) 返回String数组,表示File目录中所有字文件和目录
public File[] listFiles() 返回File数组,表示File目录中所有字文件和目录
注意
listFiles()方法和list() 方法,遍历构造方法中给出目录
如果给出的目录的路径不存在,那么就会抛出空指针异常
如果构造方法中给出的不是一个目录,那么就会抛出空指针异常
隐藏的文件或文件夹也会显示
*/
public class Demo06 {
public static void main(String[] args) {
show01();
show02();
}
/*
public File[] listFiles() 返回File数组,表示File目录中所有字文件和目录
*/
private static void show02() {
File f1 = new File("F:\\java-code\\com.a");
File[] files = f1.listFiles();
for (File file : files) {
System.out.println(file);
}
}
/*
public String[] list(FilenameFilter filter) 返回String数组,表示File目录中所有字文件和目录
遍历构造目录中文件或文件夹的名称
*/
private static void show01() {
File f1 = new File("F:\\java-code\\com.a");
String[] list = f1.list();
for (String s : list) {
System.out.println(s);
}
}
}
快捷键
idea中查看方法参数;查看类、方法、属性注释
Ctrl+P:查看方法参数
Ctrl+Q:查看类、方法、属性注释