黑马程序员_JAVA之API(Object,Scanner,数组高级,包装等类)-CSDN博客

本文链接：https://blog.csdn.net/three_for_PP/article/details/46854897

------- android培训、java培训、期待与您交流！----------

Object类：

Object是所有类的超类。内含许多本地方法。

主要方法：

public final Class getClass() 返回此运行时类。

public int hashCode() 根据地址与hash算法计算出来的一个int类型的整数两个对象的hashCode值不一样，则一定不是同一个对象

代码实现：

package cn.itcast2;

public class Demo5 {

	public static void main(String[] args) {
		Object o = method();
		//其他方法使用o
		Class clazz = o.getClass();
		System.out.println(clazz);
		
		String s = "键盘敲烂，薪资过万！";
		Class clazz2 = s.getClass();
		System.out.println(clazz2);
		System.out.println("================");
		Object o2 = new Object();
		System.out.println(o2);
		int[] arr = new int[]{12,32,43,5,6};
		System.out.println(arr);
		System.out.println("================");
		
		//获取o2与arr的hashcode值与地址对比
		int o2hash = o2.hashCode();
		System.out.println(o2hash);
		int arrhash = arr.hashCode();
		System.out.println(arrhash);
	}
	
	public static Object method(){
		return new Object();
	}
}

public String toString()

Object 类的 toString 方法返回一个字符串

使用打印语句System.out.println();打印某对象时，是先调用该对象的toString方法，再将返回的字符串打印出来

代码实现：
package cn.itcast2;

public class Demo6 {

	public static void main(String[] args) {
		
		Object o = new Object();
//		String string = o.toString();
//		System.out.println(string);
		System.out.println(o);
		
//		Person p = new Person();
		Object o2 = new Person();
		System.out.println(o2.toString());
		System.out.println(o2);
	}

}

public boolean equals(Object obj) 如果没有被重写的话，比较的是地址值

为了使Person类符合我们"正确的需求（只要年龄姓名都相同就是一个人，就应该相同，就应该返回true）"，这里重写equals即可

注意：==号只比较地址值。

代码实现（这里省略了Person类代码）

package cn.itcast2;

public class Demo7 {

	public static void main(String[] args) {
		
		int a = 10;
		int b = 20;
		System.out.println(a==b);
		
		Person p = new Person();
		Person p2 = new Person();
		System.out.println(p.hashCode());
		System.out.println(p2.hashCode());
		System.out.println(p==p2);
		
		String s = "努力到感动自己";
		String s2 = "坚持到无能为例";
		System.out.println("=====================");
		
		System.out.println(s==s2);
		System.out.println(s.equals(s2));
		
		
		Person p3 = new Person("悟能", 18);
		Person p4 = new Person("悟能", 18);
		
		System.out.println(p3==p4);
		System.out.println(p3.equals(p4));
	}

}

Scanner：

常用于控制台录入。完成获取数据的功能。

构造方法：

public Scanner(InputStream source) 构造一个新的 Scanner，它生成的值是从指定的输入流扫描的

普通方法：

public int nextXXX() 将读取到的内容转成指定类型。

public String next() 查找并返回来自此扫描器的下一个完整标记。

public String nextLine() 此扫描器执行当前行，并返回跳过的输入信息。即输入一行。

代码实现：

package cn.itcast;

import java.util.Scanner;

public class Demo {

	public static void main(String[] args) {
		
		//创建Scanner对象
		Scanner scanner = new Scanner(System.in);

		//从键盘录入int信息
//		int nextInt = scanner.nextInt();
//		System.out.println(nextInt);
//		System.out.println("===================");
		//从键盘录入字符串信息
		String next = scanner.next();
		System.out.println(next);
		
		//从键盘录入一行内容
		String nextLine = scanner.nextLine();
		System.out.println(nextLine);
	}
}

数组高级：

数组排序：

将数组的元素按照某种规则从小到大或者从大到小排列。

冒泡排序：

使用相邻的两个元素依次比较

代码实现：

package cn.itcast;

public class MaoPao {

	public static void main(String[] args) {

		int[] arr = new int[]{3,2,8,9,15,10};
		for (int i = 0; i < arr.length - 1; i++) {
			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;
				}
			}
		}
		
		method2(arr);
		System.out.println("===============");
		method(arr);
	}
	public static void method2(int[] arr){
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
	public static void method(int[] arr){
		StringBuffer sb = new StringBuffer();
		sb.append("{");
		for (int i = 0; i < arr.length; i++) {
			int j = arr[i];
			if(i == arr.length - 1){
				sb.append(j);
			}else{
				sb.append(j).append(",");
			}
		}
		sb.append("}");
		System.out.println(sb);
	}

}

选择排序：

使用一个元素，一次与后边的元素进行比较

代码实现：

package cn.itcast2;

public class Demo2 {

	public static void main(String[] args) {
		int[] arr = new int[]{12,3,5,87,9};
		
		for(int i=0;i<arr.length-1;i++) {
			for(int j=i+1; j<arr.length ; j++) {
				if(arr[i]>arr[j]) {
					int temp = arr[i];
					arr[i]= arr[j];
					arr[j]= temp;
				}
			}
		}
		
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}

}

二分法查找：

依次将所查找数据与中心数据对比，根据大小调整数据边界

代码实现：

package cn.itcast2;

public class Demo3 {

	public static void main(String[] args) {
		int[] arr = new int[]{3,5,9,12,87,100,156};
		int number = 90;
		
		int index = method(arr,number);
		System.out.println(index);
	}
	public static int method(int[] arr,int number) {
		//定义索引
		//定义开始索引
		int start = 0;
		//定义结束索引
		int end = arr.length-1;
		//定义中间的索引
		int mid = (start+end)/2;
		//只要mid不等于number,就继续判断
		while(arr[mid]!=number) {
			if(number<arr[mid]) {
				//如果要查找的数，比中间的数小，就将最后的索引变为中间的索引-1，后边的素有元素都不再判断了
				end = mid-1;
			}else {
				//如果要查找的数，比中间的数大，就将开始的索引变为中间的索引+1，前边的素有元素都不再判断了
				start = mid+1;
			}
			//如果出现开始的索引大于最后的索引，则说明数组中没有这个元素，直接返回-1
			if(start>end) {
				return -1;
			}
			//如果arr[mid]==number,则说明在数组中找到了这个数，直接返回mid即可。
			mid = (start+end)/2;
		}
		return mid;
	}

}

包装类：

对应每一种基本数据类型

以Integer为例，调用基本类型包装类对象的方法

构造方法：

public Integer(int value)

public Integer(String s)throws NumberFormatException

public static int parseInt(String s)throws NumberFormatException 将字符串转成int

public static Integer valueOf(int i) 将int转成字符串

public int intValue() 将Integer对象转成int值

代码实现：
package cn.itcast2;

public class Demo6 {

	public static void main(String[] args) {

		Integer integer = new Integer(1000);
		Integer integer2 = new Integer("1000");
		
		System.out.println(integer == integer2);
		System.out.println(integer.equals(integer2));
		
		System.out.println(integer);
		
		int parseInt = Integer.parseInt("10204");
		System.out.println(parseInt);
		
		System.out.println(100+"");
	}

}
基本类型包装类：自动装箱拆箱

以Integer为例：

装箱：使用引用数据类型的时候，可以给基本类型。即将基本数据类型提升成基本数据类型包装类对象

拆箱：使用基本数据类型时候，可以直接使用基本数据类型包装类对象。即将基本数据类型包装类对象向下转为基本数据类型

代码实现：

package cn.itcast2;

public class Demo7 {

	public static void main(String[] args) {

		Integer integer = new Integer(100);
		
		int i = 100;
		System.out.println(100-20);
		System.out.println(integer-20);
		
		integer = 108;
		System.out.println(integer);
		
//		引用类型的对象不能使用运算符运算
//		String s = "100";
//		System.out.println(s-20);
		
//		Object o = new Object();
//		System.out.println(o+100);
		
		//自动装箱：将int类型的1提升成Integer对象
		Integer x = 1;
		//自动拆箱：将Integer对象向下转成int值1
		//自动装箱：将int类型的2提升成Integer对象
		x = x + 1;
		
		Integer integer2 = null;
		//滤空判断
		//System.out.println(integer2+100);
		
	}

}

Math：

数学方法类，所有方法均为静态方法

主要方法：

public static double abs(double a) 取绝对值

public static double ceil(double a) 天花板向上取整

public static double floor(double a) 地板向下取整

public static double max(double a,double b) 取大值

public static double min(double a,double b) 取小值

public static double pow(double a, double b) 爆炸取第一个数第二个数次幂

代码实现：

package cn.itcast;

public class Demo {

	public static void main(String[] args) {

		System.out.println(Math.E);
		System.out.println(Math.PI);
		
		System.out.println(Math.abs(-125));
		
		System.out.println(Math.ceil(100.1));
		System.out.println(Math.ceil(100.9));
		System.out.println(Math.ceil(-100.1));
		System.out.println(Math.ceil(-100.9));
		System.out.println("=============================================");
		System.out.println(Math.floor(100.1));
		System.out.println(Math.floor(100.9));
		System.out.println(Math.floor(-100.1));
		System.out.println(Math.floor(-100.9));
		System.out.println("=============================================");
		System.out.println(Math.max(100, 200));
		System.out.println(Math.min(100, 200));
		System.out.println("=============================================");
		System.out.println(Math.pow(100, 2));
		System.out.println("=============================================");
		System.out.println(Math.round(100.1));
		System.out.println(Math.round(100.9));
		System.out.println(Math.round(-100.1));
		System.out.println(Math.round(-100.9));
	}

}

Random：

伪随机数生成类

伪随机原理：

通过不同的种子完成随机数的生成

构造方法：

public Random() 创建一个种子为独一无二的随机数对象

public Random(long seed) 使用单个 long 种子创建一个新的随机数生成器。

普通方法：

public int nextXX() 产生某种类型的随机数

public int nextInt(int n) 产生int类型的随机数范围[0,n)

代码实现：
package cn.itcast;

import java.util.Random;

public class Demo3 {

	public static void main(String[] args) {

		Random random = new Random();
		
		for (int i = 0; i < 100; i++) {
//			System.out.println(random.nextInt());
			System.out.println(random.nextInt(100));
		}
	}

}

System：

System类为系统相关类，不能被实例化。

主要方法：

public static void gc() 暗示垃圾回收

public static void exit(int status) 退出java程序

public static long currentTimeMillis() 获取当前时间

public static Properties getProperties() 获取系统属性

代码实现：

package cn.itcast;

import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Random;

public class Demo2 {

	public static void main(String[] args) {

		int x = 0;
		long currentTimeMillis = System.currentTimeMillis();
		
		while(true) {
			
			if(x==100000) {
				//System.exit(0);
				break;
			}
			
			Map<String,Random> map = new HashMap<String, Random>();
			map.put("abc", new Random());
			map.put("sadf", new Random());
			map.put("absdfc", new Random());
			System.out.println(map+"============"+x);
			x++;
		}
		
		long currentTimeMillis2 = System.currentTimeMillis();
		System.out.println(currentTimeMillis2-currentTimeMillis);
		System.out.println(currentTimeMillis2);
		
		Properties properties = System.getProperties();
		System.out.println(properties);
	}

}

Date：

日期类表示一个瞬间，一个时刻

构造方法：

public Date() 创建一个日期对象，现在

public Date(long date) 创建一个指定毫秒值的日期对象

public long getTime() 获取该日期对象的毫秒值

public void setTime(long time) 设置改日期对象的毫秒值

代码实现：
package cn.itcast2;

import java.util.Date;

public class Demo {

	public static void main(String[] args) {

		Date date = new Date();
		System.out.println(date);
		
		Date date2 = new Date(System.currentTimeMillis()+1000);
		System.out.println(date2);
		
		long time = date.getTime();
		long time2 = date2.getTime();
		System.out.println(time);
		System.out.println(time2);
		
		date.setTime(1000000000000L);
		System.out.println(date);
	}	

}
格式化日期：

DateFormat：DateFormat 是日期/时间格式化子类的抽象类

SimpleDateFormat：日期事件格式化类的子类具体对象

代码实现：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo2 {

	public static void main(String[] args) throws ParseException {
		
		//将日期修改为：XXXX年XX月XX日    XX-XX-XX
		Date date = new Date();
		
		//指定格式化的格式
		String pattern = "yyyy年MM月dd日 HH-mm-ss";
		
		//创建格式化类的对象
		DateFormat df = new SimpleDateFormat(pattern);
		//调用格式化类对象的方法，格式化日期对象
		String format = df.format(date);
		System.out.println(format);
		//Mon Jun 22 11:34:05 CST 2015
		
		System.out.println("====================================");
		//给定日期的字符串
		String s = "1949年02月01日  10-10-10";
		//指定格式化的格式
		String pattern2 = "yy年MM月dd日  HH-mm-ss";
		//创建格式化类的对象
		DateFormat df2 = new SimpleDateFormat(pattern2);
		//调用格式化类对象的方法,将字符串转成Date对象
		Date parse = df2.parse(s);
		System.out.println(parse);
		
	}

}

Calendar：

日历类。

构造方法：

一般不使用子类构造，而是通过父类返回实例对象的方法创建对象

Calendar rightNow = Calendar.getInstance();

普通方法：

public int get(int field) 获取指定字段的值字段中的月份是从0-11

public final void set(int year,int month, int date) 设置年月日

public abstract void add(int field, int amount) 为某个字段添加某个量

public final Date getTime() 给我一个日历对象还你一个日期对象

代码实现：
package cn.itcast2;

import java.util.Calendar;

public class Demo3 {

	public static void main(String[] args) {

		Calendar rightNow = Calendar.getInstance();
		System.out.println(rightNow);
		
		rightNow.set(2015, 5, 22);
		rightNow.add(Calendar.YEAR, 1);
		
		int i = rightNow.get(Calendar.YEAR);
		int j = rightNow.get(Calendar.MONTH);
		int k = rightNow.get(Calendar.DAY_OF_MONTH);
		
		System.out.println(i+"年"+(j+1)+"月"+k+"日");
		
		//找到rightNow变量的毫秒值
		long time = rightNow.getTime().getTime();
		System.out.println(time);
	}

}