day04 【Object 类、常用 API】
今日内容介绍
java
Object类
日期类
日期格式化
日历类
System
Arrays
正则表达式第一章 Object 类
1.1 Object 类的特点【重点】
java
1.java.lang.Object类的介绍:
是整个类的体系结构中的最顶层父类,是所有类的最终父类,它里面定义的方法,其它类都有.
类Object是类层次结构的根类。每个类都使用Object作为超类。所有对象（包括数组）都实现这个类的方法。
2.常用方法:
(1)public String toString(): 返回调用方法的对象的字符串表示形式
(2)public boolean equals(Object obj): 比较调用方法的对象和方法参数对象是否相等
true: 说明相等
false: 说明不相等1.2 Object 类的 toString 方法【重点】
java
/*
toString方法的注意:
1.Object类的toString方法默认返回对象的地址值,类的全名称 + @ + 16进制的int数字
内部源代码分析:
public String toString() {
return getClass().getName() + "@"
+ Integer.toHexString(hashCode());
}
getClass().getName(): 获取类的全名称
Integer.toHexString(hashCode()): 把对象的哈希值转换成16进制的int数字
2.自定义类,如果没有覆盖重写Object类的toString方法,默认调用Object类的toString方法,返回对象地址值
3.自定义类,返回对象的地址值没有意义,需要返回的是对象的内容,所以自定义类需要覆盖重写Object类的toString方法
目的: 返回对象的内容,而不是地址值
快捷键: alt + insert --> toString --> 选择成员变量 --> ok
注意:
打印引用类型变量,默认调用toString方法
*/java
package com.itheima.object01;
// 我们不写继承 Object 也会默认继承Object类
public class Student extends Object{
//Student对象可以调用Object中定义功能！
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.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;
}
// 如果想让toString有更好展示效果
// 需要进行重写
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}java
package com.itheima.object01;
public class Demo {
public static void main(String[] args) {
//Object是父类 --默认有很多功能
Object obj = new Object();
// 自己调用自己的方法
/*
public String toString()返回该对象的字符串表示
*/
System.out.println("obj.toString():"+obj.toString());
// java.lang.Object@1b6d3586
//查看源码发现
// return getClass().getName() + "@" + Integer.toHexString(hashCode());
// 获取包名+类名 @ 地址值
// Student是子类
Student stu = new Student();
System.out.println("stu.toString():"+stu.toString());
// 如果没有重写父类的方法 是不是也是 包名+类名@地址
// stu.toString():com.itheima.object01.Student@4554617c
// 重写之后 stu.toString():Student{name='null', age=0}
// 有个学生对象 你想看什么 想看里面内容
// 能不能把这个方法重写了 ，调用之后 展示里面的属性值
Student stu2 = new Student("张同学",38);
System.out.println("调用stu2.toString方法展示里面的内容:"+stu2.toString());
System.out.println(stu2);// 打印引用类型变量,默认调用toString方法
}
}
String 是 Object 子类，sout("sss") 得到结果 sss 而不不是 地址值 说明重写了。
1.3 Object 类的 equals 方法【重点】
java
/*
equals方法的注意:
1.Object类的equals方法默认比较对象的地址值,然而只要new对象的地址值就是不相同的
内部源代码分析:
public boolean equals(Object obj) {
return (this == obj);
}
this代表: 调用方法的对象
obj代表: 调用方法时传递的参数对象
==: 在比较两个对象的内存地址值是否相同
2.自定义类,如果没有覆盖重写Object类的equals方法,默认调用Object类的equals方法,比较对象的地址值
3.自定义类,比较对象的地址值没有意义,需要比较的是对象的内容,
所以自定义类需要覆盖重写Object类的equals方法
目的: 比较对象的内容,而不是地址值
快捷键: alt + insert --> equals && hashCode() --> 选择成员变量 --> ok
4.==的使用:
(1)基本类型变量: 比较的是具体的数据值
(2)引用类型变量: 比较的是对象的内存地址值是否相同
*/java
public class Demo04Equals {
public static void main(String[] args) {
Object obj1 = new Object();
Object obj2 = new Object();
//Object类equals方法内部使用==比较对象的地址值,所以使用equals和==的结果是相同的
//两个对象都是new出来的,只要new对象的内存地址值就不相同
System.out.println(obj1.equals(obj2));//false
System.out.println(obj1 == obj2);//false
}
}
1.4 Object 类的 equals 方法重写【重点】
java
public class Student extends Object {
private String name;
private int age;
/*
覆盖重写toString方法
目的: 返回对象的内容,而不再返回地址值
*/
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
/*
覆盖重写equals方法
目的: 比较对象的内容,而不再比较对象的地址值
认为: 姓名相同 同时 年龄也相同,这两个对象就是相同的
*/
@Override
public boolean equals(Object o) {
//this == o: 调用方法的对象和参数对象是同一个对象,直接返回true
//如果自己和自己比,内容必然相同,不用比了直接返回true
if (this == o) return true;
/*
o == null: 如果参数对象是null,直接返回false
||: 或者
getClass() != o.getClass(): 反射讲,调用方法的对象和参数对象不是同一个类的对象,直接返回false getClass()查看对象是基于哪个类产生的意思
*/
//if (o == null || getClass() != o.getClass()) return false;
//和下面的写法是等价的
if (o == null || !(o instanceof Student)) return false;
//向下转型: 把参数对象,强转成Student对象
Student student = (Student) o;
/*
age == student.age: 判断两个对象的年龄是否相同
&&: 并且
Objects.equals(name, student.name): 调用工具类Objects静态方法equals
比较引用类型两个字符串是否相同
*/
return age == student.age &&
Objects.equals(name, student.name);
}
//空参/满参,set/get方法 自己生成
}java
public class Demo05Equals {
public static void main(String[] args) {
Student stu1 = new Student("张三", 18);
Student stu2 = new Student("李四", 38);
Student stu3 = new Student("张三", 18);
/*
Student类没有覆盖重写Object类的equals方法
结果: false,false,false
Student类覆盖重写Object类的equals方法
结果: false,true,false
*/
System.out.println(stu1.equals(stu2));
System.out.println(stu1.equals(stu3));
System.out.println(stu2.equals(stu3));
}
}第二章 Date 类【重点】
2.1 Date 类的介绍和基本使用
java
/*
1.java.util.Date类介绍:类 Date 表示特定的瞬间，精确到毫秒。
2.注意:
(1)时间原点: 1970年1月1日 0时0分0秒 认为是0毫秒
(2)时间标准: 采用格林威治时间标准
(3)北京时间与标准时间相差8小时
3.构造方法:
(1)public Date(): 把当前时间毫秒值(运行程序的此时此刻)封装成Date对象
(2)public Date(long date): 把构造方法参数指定的毫秒值封装成Date对象
4.常用常用方法:
(1)public long getTime(): 返回调用方法的Date对象对应的毫秒值
(2)public void setTime(long time): 把方法参数指定的毫秒值设置给调用方法的Date对象
*/java
package com.itheima.date02;
import java.util.Date;
public class DateDemo {
/*
Date 表示日期时间 精确到毫秒值
Date() 获取当前时间 (把当前时间毫秒值转换为一个对象)
当前时间毫秒值 :就是计算当前时间-1970-1-1-0-0-0 之后 转换为毫秒的值。
Date(long time) :把传递的时间毫秒值转换成一个对象
方法 getTime() 获取date对象的时间毫秒值
setTime(时间毫秒值)//重新设置一个时间点 用毫秒值
*/
public static void main(String[] args) {
Date date = new Date();
System.out.println(date);
// 当前时间对象有了能不能变成毫秒值
long time = date.getTime();
System.out.println(time);
// Date(long time) :把传递的时间毫秒值转换成一个对象
Date date1 = new Date(60*1000);
System.out.println(date1);
date1.setTime(60*1000*60);
System.out.println("设置时间之后"+date1);
}
}第三章 DateFormat 类【重点】
3.1 DateFormat 类的介绍
java
/*
java.text.DateFormat类:
1.作用:
用来完成Date对象和String对象之间的相互转换的
2.常用功能
(1)格式化(就是把Date对象转换成String对象)
public String format(Date date): 把方法参数Date对象转换成String对象并返回
参数:
Date date: 日期对象
返回值:
String: 返回的是String对象
(2)解析(就是把String对象转换成Date对象)
public Date parse(String source): 把方法参数String对象转换成Date对象并返回
参数:
String source: String对象
返回值:
Date: 返回的是日期对象
3.使用
java.text.DateFormat是一个抽象类,不能直接new对象
常用子类:java.text.SimpleDateFormat类
构造方法:
public SimpleDateFormat(String pattern)
参数:
String pattern: String类型的日期格式
显示格式 需要设置的日期格式
2020年09月23日 10点43分20秒123毫秒 yyyy年MM月dd日 HH点mm分ss秒SSS毫秒
2020-09-23 10:43:20:123 yyyy-MM-dd HH:mm:ss:SSS
*/3.2 日期格式化为字符串【重点】
java
/*
把Date对象格式化成String对象的实现步骤
1.创建String类型的日期格式对象patter,需要指定具体的格式
2.创建日期格式化SimpleDateFormat类的对象sdf,构造方法参数传递日期格式对象patter
3.创建当前毫秒值对应的日期Date对象date
4.使用日期格式化SimpleDateFormat类的对象sdf调用format方法,传递日期对象date,
获取指定格式的String对象
5.打印String对象
*/java
public class Demo04DateFormat {
public static void main(String[] args) {
//1.创建String类型的日期格式对象patter,需要指定具体的格式
String patter = "yyyy年MM月dd日 HH点mm分ss秒SSS毫秒";
//2.创建日期格式化SimpleDateFormat类的对象sdf,构造方法参数传递日期格式对象patter
SimpleDateFormat sdf = new SimpleDateFormat(patter);
//3.创建当前毫秒值对应的日期Date对象date
Date date = new Date();
//4.使用日期格式化SimpleDateFormat类的对象sdf调用format方法,传递日期对象date,
//获取指定格式的String对象
String strDate = sdf.format(date);
//5.打印String对象
System.out.println(strDate);
}
}3.3 字符串转换成日期【重点】
java
/*
把String对象解析成Date对象的实现步骤
1.创建String类型的日期格式对象patter,需要指定具体的格式
2.创建日期格式化SimpleDateFormat类的对象sdf,构造方法参数传递日期格式对象patter
3.创建String对象strDate,保存指定格式的日期时间
4.使用日期格式化SimpleDateFormat类的对象sdf调用parse方法,传递String的日期对象strDate,
获取Date对象
5.打印Date对象
*/java
public class Demo05DateFormat {
public static void main(String[] args) throws ParseException {
//1.创建String类型的日期格式对象patter,需要指定具体的格式
String patter = "yyyy年MM月dd日 HH点mm分ss秒SSS毫秒";
//2.创建日期格式化SimpleDateFormat类的对象sdf,构造方法参数传递日期格式对象patter
SimpleDateFormat sdf = new SimpleDateFormat(patter);
//3.创建String对象strDate,保存指定格式的日期时间
String strDate = "2020年09月23日 10点54分22秒442毫秒";
//String strDate = "2020-09-23 10:54:22:442";//错误: 和上面的日期格式不匹配,报出解析异常
//4.使用日期格式化SimpleDateFormat类的对象sdf调用parse方法,传递String的日期对象strDate,
//获取Date对象
Date date = sdf.parse(strDate);
//5.打印Date对象
System.out.println(date);
}
}第四章 Calendar 日历类【重点】
4.1 Calendar 类的介绍
java
/*
java.util.Calendar类: 日历类,内部提供了大量的与日期时间相关的信息,想要什么就那什么,非常方便
java.util.Calendar类是一个抽象类,不能直接创建对象
不常用子类: java.util.GregorianCalendar类 用起来太麻烦
解决方案:
在java.util.Calendar类的内部提供静态方法获取其子类对象
public static Calendar getInstance(): 获取抽象类Calendar类的子类对象
返回值类型:
java.util.Calendar类: 是抽象类,说明方法内部必然会返回该抽象类的子类对象
*/
public class Demo03Calendar {
public static void main(String[] args) {
//获取Calendar类的子类对象
Calendar cal = Calendar.getInstance();
System.out.println(cal);
}
}4.2 Calendar 类的常用方法
java
/*
Calendar类的常用方法
public int get(int field) ：返回给定日历字段的值。
参数:
int field: 代表的是要获取的是哪个字段
返回值:
int: 代表的是获取到的字段对应的值
public void set(int field, int value) ：将给定的日历字段设置为给定值。
参数:
int field: 代表的是要给哪个字段设置值
int value: 代表的是设置的值是什么
public abstract void add(int field, int amount) ：
根据日历的规则，为给定的日历字段添加或减去指定的时间量。
给指定字段增加指定的值
参数:
int field: 代表的是要给哪个字段增加值
int amount: 代表的是增加的值是多少
正数表示增加,负数表示减少
public Date getTime() ：把调用方法的Calendar对象转换成Date对象并返回
public void setTime(Date date): 把调用方法传递的参数Date对象设置给调用方法的Calendar对象
Calendar类当中的常量
Calendar.YEAR 代表年 1
Calendar.MONTH 代表月 2
Calendar.DAY_OF_MONTH 代表日 5
*/java
package com.itheima.calendar;
import java.util.Calendar;
public class Demo {
public static void main(String[] args) {
//创建一个日历类对象 只能通过静态方法
Calendar calendar = Calendar.getInstance();
System.out.println(calendar);
// calendar日历类 作用 可以获取任意时间元素
/*
获取方法
int get(int filed)
返回值 就是时间元素的值
参数代表 你来进行选择
*/
//获取年
int year = calendar.get(Calendar.YEAR);
// int year = calendar.get(1);上面的写法比单纯的写 1 要见名之意
System.out.println(year+"年");
//获取月
int month = calendar.get(Calendar.MONTH);
System.out.println((month+1)+"月");
// 获取日 月中日
int date = calendar.get(Calendar.DATE);
System.out.println(date+"日");
//单独设置某一个时间元素 set(需要设置的日期元素,值)
calendar.set(Calendar.YEAR,2011);
System.out.println("我把日历中的年改成了 2011 其他没有改");
System.out.println(calendar.get(Calendar.YEAR)+"年"+(calendar.get(Calendar.MONTH)+1)+"月"+calendar.get(Calendar.DATE)+"日");
//现在已经是 2011年12月30日
// 进行某个时间元素的偏移 往前 还是往后
calendar.add(Calendar.YEAR,10);
System.out.println(calendar.get(Calendar.YEAR)+"年"+(calendar.get(Calendar.MONTH)+1)+"月"+calendar.get(Calendar.DATE)+"日");
}
}4.3 Calendar 类案例
java
package com.itheima.calendar;
import java.util.Calendar;
import java.util.Scanner;
public class Test {
/*
键盘录入年份
我们告知 该2月多少天
3 1 往前移动一天 2月末 29 月中日 29 28 月中日28
实现步骤
1:创建键盘录入对象 Scanner
2：友情提示 录入一个年份 sc.nextInt()
3: 创建一个日历对象 设置年份是 录入的 设置月 3-1 = 2 (0,1,2) 设置日 1 日
4: 让日历对象 add向前偏移 一天
5: 查看月中日 是多少 2月就是多少天
*/
public static void main(String[] args) {
// 1:创建键盘录入对象 Scanner
Scanner scanner = new Scanner(System.in);
// 2：友情提示 录入一个年份 sc.nextInt()
System.out.println("你录入一个整数年份，我帮您查一下该年2月是多少天 ");
int year = scanner.nextInt();
//3:创建一个日历对象 设置年份是 录入的 设置月 3-1 = 2 (0,1,2) 设置日 1 日
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.YEAR,year);
calendar.set(Calendar.MONTH,2);//设置3月
calendar.set(Calendar.DATE,1);
//它是 3月1日
//4: 3月1日的前一天是 2月的最后一天
calendar.add(Calendar.DATE,-1);
//5:查看月中日 是多少 2月就是多少天
System.out.println("该"+year+"年的2月是:"+calendar.get(Calendar.DATE)+"天");
}
}第五章 System 类的使用【了解】
5.1 System 类的介绍
java
/*
java.lang.System类: 用来完成相关系统操作的工具类
工具类的特点:
1.所有的成员都是static修饰的,直接用类名调用即可,不需要对象
2.把构造方法private修饰
常用方法:
public static void exit(int status): 终止当前正在运行的 Java 虚拟机。
参数:
int status: 0表示正常终止JVM,非0表示异常终止JVM
*/java
package com.itheima.system05;
public class Demo {
public static void main(String[] args) {
/*
JVM退出命令
*/
for (int i = 0; i <100 ; i++) {
System.out.println(i);
if(i==50){
// break;//结束了所在的循环
// return;//结束该方法
System.exit(0);//JVM虚拟机结束了
}
}
System.out.println("main方法结束了");
}
}5.2 System 类的练习_获取程序执行的时间
java
/*
System类的静态方法
public static long currentTimeMillis(): 获取当前时间的毫秒值
等价于: new Date().getTime()
需求:在控制台输出1-10000，计算这段代码执行了多少毫秒!
实现步骤:
1.获取开始时间对应的毫秒值
2.执行功能代码
3.获取结束时间对应的毫秒值
4.计算总耗时并输出
*/java
package com.itheima.system05;
public class Demo2 {
public static void main(String[] args) {
//System可以获取当前时间的毫秒值
// 当前时间和1970 1月1日 0:0:0 之间的差值 转换成了 毫秒
//获取当前时间毫秒值
long start = System.currentTimeMillis();
for (int i = 0; i <10000000 ; i++) {
System.out.println("你追我.....追追追");
}
long end = System.currentTimeMillis();
System.out.println("这个程序用时:"+(end-start)+"毫秒");
}
}5.3 System 类的练习_数组拷贝
java
package com.itheima.system05;
import java.util.Arrays;
public class Demo3 {
public static void main(String[] args) {
//数组的copy方法
//源数组
int[] srcArr = {10,20,30,40,50,60};
//目标数组
int[] destArr = {100,200,300,400,500,600,70,80,90};
System.out.println("源数组数据:"+Arrays.toString(srcArr));//打印数组中的数据内容
System.out.println("目标数组数据:"+Arrays.toString(destArr));//打印数组中的数据内容
//实现 srcArr数组中部分数据 copy到 目标数组的指定位置
//源数组 从 30这个元素位置2开始 复制到 目标数组 3位置 复制三个元素
/*
static void arrayCopy(Object src，int srcPos,Object dest，int destPos,int length)
src 源数组 srcPos 源数组的起始位值
dest 目标数组 destPos 目标数组的起始位值 length 复制几个
*/
System.arraycopy(srcArr,2,destArr,3,3);
System.out.println("源数组数据:"+Arrays.toString(srcArr));//打印数组中的数据内容
System.out.println("目标数组数据:"+Arrays.toString(destArr));//打印数组中的数据内容
}
}5.4 System 类的 gc 方法
java
/*
java.lang.System类: 用来完成相关系统操作的工具类
常用方法:
public static void gc(): 运行垃圾回收器。
运行垃圾回收器，JVM将从堆内存中清理对象，
清理对象的同时会调用对象的finalize()方法，建议自定义类覆盖重写finalize()方法
JVM的垃圾回收器是通过另一个线程开启的
*/
public class Demo05System {
public static void main(String[] args) {
for (int i = 0; i < 1000; i++) {
new Student();
}
System.gc();//建议运行垃圾回收器
System.out.println("main...end...");
}
}
public class Student {
@Override
protected void finalize() throws Throwable {
System.out.println("对象被回收了...");
}
}第六章 冒泡排序
两个元素交换，该如何实现位置互换
java
package com.itheima.paixu;
import java.util.Arrays;
public class Demo01 {
/*
两个元素交换位置 需要用到第三方的变量
*/
public static void main(String[] args) {
int[] arr = {2,3};
//要求你 让 arr[1] arr[0] 换位置
int temp = arr[0];
arr[0] =arr[1];
arr[1]=temp;
System.out.println(Arrays.toString(arr));
}
}6.1 冒泡排序原理
java
/*
冒泡排序
1.原理:
每次都是从第一个元素开始向后两两进行比较,
只要后面的元素小于前面的元素,就交换这两个元素(从小到大)
2.总结:
1.有5个数需要排4趟,有n个数需要n-1趟
2.每趟排序的次数都比前面一趟少1次
3.规律:
第一趟 第二趟 第三趟 第四趟
[0] VS [1] [0] VS [1] [0] VS [1] [0] VS [1]
[1] VS [2] [1] VS [2] [1] VS [2]
[2] VS [3] [2] VS [3]
[3] VS [4]
*/
6.2 冒泡排序代码实现
java
package com.itheima.paixu;
import java.util.Arrays;
public class BubbleSortDemo {
public static void main(String[] args) {
//定义一个数组
int[] arr = {7,50,4,6,3,12,30,1};
// 对数组中的元素进行排序 数组中的元素是按照升序排列
//最终效果 arr={3,4,5,6,7}
//由无序变有序 需要动点脑筋了 方式方法有很多种。
System.out.println("排序前的："+Arrays.toString(arr));
// 冒泡排序--算法
// 外层循环 决定 趟数 4趟
// 写4 就写死了长度 4 数组长度-1
for (int i = 0; i <arr.length-1 ; i++) {
// i=0的时候 是第一趟 第一趟要比较几次 4次
// i = 1 的时候 是第二趟 第二趟比较 3次
// i 2 第三趟 比较2次
// i 3 第四趟 比较1次
for(int j=0; j<arr.length-1-i; j++){
// 元素两两比较 大的往后放
if(arr[j]>arr[j+1]){// 前面元素大于后面的 就要交换
//位置交换
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
System.out.println("排好序的数组为:"+ Arrays.toString(arr));
}
}第七章 数组的二分查找法
7.1 数组元素的普通查找法
java
/*
要求:
在int数组中查找某个元素第一次出现的索引,如果没有该元素,返回-1
10,20,30,50,80
定义方法在int数组中获取一个元素第一次出现的索引值,如果没有返回-1
三要素:
1.方法名称: getIndex
2.参数列表:
int[] array: 要查找元素的int数组
int value: 要在数组中查找的元素
3.返回值类型: int
实现步骤:
1.使用for循环遍历方法参数数组array
1.1 如果当前元素值 等于 要查找的元素value
1.2 直接返回当前元素的索引
2.for循环结束,说明没有找找该元素,直接返回-1
*/java
package com.itheima.binarysearch;
public class Demo {
/*
10,20,30,50,80
定义方法在int数组中获取一个元素第一次出现的索引值,如果没有返回-1
*/
public static void main(String[] args) {
int[] arr = {10,20,30,50,80};
System.out.println("找到30在数组中的索引:"+getIndex(arr,30));
System.out.println("找到300在数组中的索引:"+getIndex(arr,300));
System.out.println("找到50在数组中的索引:"+getIndex(arr,50));
}
/*
定义一个方法
用来寻找 某个数组中 某个元素 返回该元素在数组中的索引
方法 三要素
一个必须
方法名 getIndex
两个确定
确定 参数 int[] array int value
确定 返回值类型 int
如果找到元素 返回元素的索引
找不到返回-1
*/
public static int getIndex(int[] array,int value){
//代码怎么写？
for (int i = 0; i < array.length; i++) {
if(array[i]==value){
//说明有该元素 返回i
return i;
}
}
//找不到 就返回-1
return -1;
}
}7.2 二分查找原理
java
/*
前提:
1.数组必须要保证是有序的
2.数组元素不能重复
原理:
取数组中间的元素和被查找的元素进行比较，如果被查找元素大于数组中间元素，
就舍去数组元素左的一半，对另一半继续进行查找。
*/
7.3 二分查找代码实现
java
package com.itheima.binarysearch;
public class BinaryDemo {
/*
二分查找使用有要求
1:数组元素有序
2:没有重复元素
*/
public static void main(String[] args) {
int[] arr = {10,20,30,50,80};
System.out.println("找到30在数组中的索引:"+binarySearch(arr,30));
System.out.println("找到300在数组中的索引:"+binarySearch(arr,300));
System.out.println("找到50在数组中的索引:"+binarySearch(arr,50));
}
/*
二分查找方式 查找指定元素在数组中的索引
如果有就返回索引 如果没有返回-1
value是被查找元素
*/
public static int binarySearch(int[] array,int value){
// 1：定义两个变量 表示查找范围
int start = 0;
int end = array.length-1;
// 2:循环查找
while(start<=end){
// 在可查找范围内
// 3:找出中间位置元素 计算出中间元素索引
int mid = (end+start)/2;
//怎么找中间元素
// array[mid]
// 中间元素和被查找元素 value 进行比较
if(array[mid]>value){//中间元素大于被查找的元素
// 右边不要 end移动左边 mid 左边
end = mid-1;
}else if(array[mid]<value){//中间元素小于被查找的元素
// 左边不要 start移动右边 mid的右边
start = mid+1;
}else{//等于 说明找到了
return mid;
}
}
//循环做完都没找到就真找不到了
return -1;
//
}
}第八章 Arrays 工具类的使用
8.1 工具类 Arrays 的用法
java
/*
java.util.Arrays类: 此类是用来操作数组的工具类
工具类的特点:
1.所有的成员都是static修饰的,直接用类名调用即可,不需要对象
2.把构造方法private修饰
常用方法:
public static void sort(int[] a) 对指定的int数组进行升序排列
public static int binarySearch(int[] a,int key):
对数组进行二分查找法，找不到元素返回(-插入点)-1
public static String toString(int[] a) 将数组转成字符串
*/
public class Demo06Arrays {
public static void main(String[] args) {
//定义数组
int[] array = {10,9,3,6,5,1,2};
System.out.println("排序前: "+Arrays.toString(array));
//调用方法按照从小到大的顺序排序
MyArrays.sort(array);
System.out.println("排序后: "+Arrays.toString(array));
System.out.println("二分超找1: "+Arrays.binarySearch(array,1));//0
System.out.println("二分超找6: "+Arrays.binarySearch(array,6));//4
System.out.println("二分超找10: "+Arrays.binarySearch(array,10));//6
}
}