JavaSE

最新推荐文章于 2024-04-08 15:12:12 发布

置顶麦子程序

最新推荐文章于 2024-04-08 15:12:12 发布

阅读量671

点赞数 3

分类专栏： Java基础文章标签： java

本文链接：https://blog.csdn.net/qq_38656657/article/details/120333264

版权

Java基础专栏收录该内容

2 篇文章 0 订阅

订阅专栏

JavaSE（上）

1.API概述

1.1.知识概述

API(Application Programming Interface),应用程序编程接口。JavaAPI是提供给开发者的查询手册，是JDK中提供给我们使用类的说明文档。这些类将底层的代码进行了封装，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。所以我们可以通过查询API手册的方式，来学习Java类库中提供的类，并得知如何使用它们。

1.2.API手册使用步骤

1.打开帮助文档。

2.点击显示，点击索引，找打输入框。

3.要找那个类或接口？在输入框中输入然后回车。

4.看包。

5.看类的解释和说明。

6.学习构造方法。

7.使用成员变量和成员方法。

1.3.课堂提问

1.JDK目前最新的是哪个版本？

2.API手册1.8及1.6为什么使用JDK1.8，却仍然还使用1.6API手册？

因为JDK1.6中文手册是SUN公司官方翻译的中文简体手册，而JDK1.8手册是其他翻译软件的译本，不太标准。

1.4.JDK包结构

包	功能
java.lang	Java程序的基础类，如字符串、多线程等，该包中的类使用的频率非常高，所以此包下的类在使用过程中不需要导包。
java.util	常用的工具类，如Scanner、集合、随机数生成器、日历、时钟。
java.io	Java对系统文件的操作类，读写操作。
java.net	Java中的网络操作。
java.math	Java中数学运算操作。
java.security	Java中安全相关操作。
java.text	Java中处理文字、日期、数字信息等格式。

1.5.文档注释

在这里插入图片描述

2.Scanner类

2.1.知识概述

一个可以解析基本数据类型和字符串的简单文本扫描器。

2.2.引用数据类型的使用步骤

1.导包

使用import关键字导包，引入要使用的类型，注意java.lang包下的类不需要导包。

格式：

import 包名.类名;

举例：

import java.util.Scanner;

2.创建对象

使用该类的构造方法创建该类的对象。

格式：

数据类型 对象名=new 数据类型();

举例：

Scanner scan=new Scanner(System.in);

3.使用属性或方法

使用该类的成员方法完成指定功能。

格式：

对象名.方法名();

举例：

int i=sacn.nextInt();//接收键盘输入的Int类型的整数。

使用Scanner完成键盘录入的代码：

package cn.tedu.Scanner;
import java.util.Scanner;
/**
 * 一.知识概述：
 *  一个可以解析基本数据类型和字符串的简单文本扫描器。
 * 二.引用数据类型的使用步骤
 * 1.导包
 *  使用import关键字导包，引入要使用的类型，注意java.lang包下的类不需要导包。
 *  格式：import 包名.类名；
 * 2.创建对象
 *  数据类型 对象名=new 数据类型();
 * 3.使用属性或方法
 *  对象名.方法名();
 *  
 * @author Administrator
 *
 */
public class ScannerDemo1 {

	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		System.out.println("请输入数字:");
		int num=scan.nextInt();
		System.out.println("扫描到的数字为:"+num);
		//关闭扫描器
		scan.close();
	}

}

package cn.tedu.Scanner;
import java.util.Scanner;
/**
 * 一.知识概述：
 *  一个可以解析基本数据类型和字符串的简单文本扫描器。
 * 二.引用数据类型的使用步骤
 * 1.导包
 *  使用import关键字导包，引入要使用的类型，注意java.lang包下的类不需要导包。
 *  格式：import 包名.类名；
 * 2.创建对象
 *  数据类型 对象名=new 数据类型();
 * 3.使用属性或方法
 *  对象名.方法名();
 * @author Administrator
 *
 */
public class ScannerDemo2 {

	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		System.out.println("请输入文字:");
		String num=scan.nextLine();
		System.out.println("扫描到的文字为:"+num);
		//关闭扫描器
		scan.close();
	}
}

2.3.面试重点

next()方法和nextLine()方法的区别?

Scanner中next()和nextLine() 方法都可以扫描控制台的字符串，区别在于next()方法遇见第一个有效字符(非空格或换行符)时开始扫描，当遇见第一个分隔符或结束符，结束扫描。nextLine()方法获取一行内容并作为字符串返回，遇见换行符时结束。

3.Random类

3.1.知识概述

此类主要生成随机数。

3.2.Random类的使用步骤

1.查看类(导包)

java.util.Random:该类需要import导包

2.查看构造方法(创建对象)

public Random():创建一个新的随机数生成器

3.查看成员(使用成员方法或变量)

public int nextInt():返回一个随机数，随机范围为-2147483648到2147483647均匀分配。
public int nextInt(int n):返回一个随机数，随机范围为0(包括)到n(不包括)之间均匀分配。
public long nextLong():返回一个随机数，随机范围为long的取值范围之间均匀分配。
public double nextDouble():返回一个随机数，随机范围为double取值范围之间均匀分配。
public boolean nextBoolean():返回一个随机数，随机范围为boolean均匀分配(true、false)。

3.3.课堂练习

使用Random生成3个随机数，范围在0-50之间。

package cn.tedu.Random;
//1.导包
import java.util.Random;
/**
 * 课堂练习：
 * 生成3个随机数，范围在0-50之间。
 * @author Administrator
 */
public class RandomDemo2 {

	public static void main(String[] args) {
		//2.创建对象
		Random ran=new Random();
		//3.使用循环生成随机数
		for(int i=0;i<3;i++){
			int num=ran.nextInt(50);
			System.out.println(num);
		}
	}
}

3.4.课后作业

使用Random生成3个随机数，并全部输出打印到控制台，并取出3个随机数中的最大值。

package cn.tedu.API;

/**
 * 使用Random生成3个随机数，并全部输出打印到控制台，并取出3个随机数中的最大值。
 */

import java.util.Random;

public class HomeWork {
    public static void main(String[] args) {
        Random random = new Random();
        int a=random.nextInt(100);
        int b=random.nextInt(100);
        int c=random.nextInt(100);
        System.out.println("随机数一:"+a+"随机数二:"+b+"随机数三:"+c);
        int temp=a>b?a:b;
        int max=temp>c?temp:c;
        System.out.println("最大值为:"+max);
    }
}

4.Math类

4.1.知识概述

java.lang.Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

类似这样的工具类，其所有方法均分静态方法，并且不会创建对象，调用起来非常简单。

4.2.基本运算的方法

public static int abs(int a):返回int类型a的绝对值。

  //返回int类型a的绝对值。
   int abs1 = Math.abs(5);
   System.out.println(abs1);//5
   int abs2 = Math.abs(-5);
   System.out.println(abs2);//5

public static double ceil(double a):返回大于等于参数a的最小整数。

   //返回大于等于参数a的最小整数。
    double ceil1 = Math.ceil(4.1);
    System.out.println(ceil1);//5.0
    double ceil2 = Math.ceil(-3.3);
    System.out.println(ceil2);//-3.0

public static double floor(double a):返回小于等于参数的最大整数。

   //返回小于等于参数的最大整数。
   double floor1 = Math.floor(3.3);
   System.out.println(floor1);//3.0
   double floor2 = Math.floor(-3.3);
   System.out.println(floor2);//-4.0

public static long round(double a):返回最接近参数a的long值。(类似于四舍五入)

    //返回最接近参数a的long值。(类似于四舍五入)
    long round1 = Math.round(5.5);
    System.out.println(round1);
    long round2 = Math.round(-5.5);
    System.out.println(round2);

public static double random():返回0(包括)到1(不包括)之间的随机小数。

//返回0(包括)到1(不包括)之间的随机小数。
double random = Math.random();
System.out.println(random);

完整代码：

package cn.tedu.Math;
/**
 * Math类概述：
 * java.lang.Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
 * 类似这样的工具类，其所有方法均分静态方法，并且不会创建对象，调用起来非常简单。
 * Math类的基本运算方法：
 * public static int abs(int a):返回int类型a的绝对值。
 * public static double ceil(double a):返回大于等于参数a的最小整数。
 * public static double floor(double a):返回小于等于参数的最大整数。
 * public static long round(double a):返回最接近参数a的long值。(类似于四舍五入)
 * public static double random():返回0(包括)到1(不包括)之间的随机小数。
 * @author MaYF
 *
 */
public class MathDemo1 {

	public static void main(String[] args) {
		// 返回int类型a的绝对值。
		int abs1 = Math.abs(5);
		System.out.println(abs1);// 5
		int abs2 = Math.abs(-5);
		System.out.println(abs2);// 5
		System.out.println("---------------");
		// 返回大于等于参数a的最小整数。
		double ceil1 = Math.ceil(4.1);
		System.out.println(ceil1);// 5.0
		double ceil2 = Math.ceil(-3.3);
		System.out.println(ceil2);// -3.0
		System.out.println("---------------");
		// 返回小于等于参数的最大整数。
		double floor1 = Math.floor(3.3);
		System.out.println(floor1);// 3.0
		double floor2 = Math.floor(-3.3);
		System.out.println(floor2);// -4.0
		System.out.println("---------------");
		// 返回最接近参数a的long值。(类似于四舍五入)
		long round1 = Math.round(5.5);
		System.out.println(round1);
		long round2 = Math.round(-5.5);
		System.out.println(round2);
		System.out.println("---------------");
		// 返回0(包括)到1(不包括)之间的随机小数。
		double random = Math.random();
		System.out.println(random);
	}
}

4.3.课堂练习

请使用Math相关的API方法，计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？

package cn.tedu.homework;
/**
 * 请使用Math 相关的API，计算在 -10.8 到5.9 之间，绝对值大于6 或者小于2.1 的整数有多少个？
 * @author MaYF
 */
public class ABSCount {

	public static void main(String[] args) {
		// 定义最小值
		double min =-10.8;
		// 定义最大值
		double max = 5.9;
		// 定义变量计数
		int count = 0;
		// 范围内循环 
		for (double i = Math.ceil(min); i <= max; i++) {
			// 获取绝对值并判断 
			if (Math.abs(i) > 6 || Math.abs(i) < 2.1) {
				// 计数
				count++;
			}
		}
		System.out.println("个数为: " + count + " 个");
		}
}

5.String类

5.1.知识概述

java.lang.String类代表字符串。Java程序中所有的字符串文字(例如“abc”)都可以被看做是实现此类的实例。

String类中包括用于检测各个字符串的方法。如用于比较字符串，搜索字符串，提取子字符串以及创建具有转换为大写或小写的所有字符的字符串的副本。

5.2.字符串特点

1.字符串是不变的：字符串的值在创建之后不能更改(final修饰)。

package cn.tedu.String;
/**
 * String类
 * 特点：
 * 1.String不可变
 * @author Administrator
 *
 */
public class StringDemo1 {

	public static void main(String[] args) {
		String s="abc";
		System.out.println(s);
		String s1=s+"d";
		//s+="d";
		System.out.println(s);
		System.out.println(s1);

	}
}

2.字符串共享： 因为String对象是不可变的，所以它们是可以被共享的。

3.底层存储：“abc”等效于char[] data={‘a’,‘b’,‘c’};字符数组字符—》字符串

字符串String中使用char数组存储，char的底层byte[]字节数组。

在这里插入图片描述

5.3.使用步骤

1.查看类

java.lang.String:此类不需要导包。

2.查看构造方法

public String()：创建新的String对象，以空字符序列创建。

public String(char[] value):通过当前参数中字符数组value来创建新的字符串对象。

public String(byte[] bytes):通过使用平台默认的字符集解码参数中的字节来创建字符串对象。

package cn.tedu.String;
/**
 * String类使用构造方法创建
 * public String()：创建新的String对象，以空字符序列创建。
 * 
 * public String(char[] value):
 * 通过当前参数中字符数组value来创建新的字符串对象。
 * 
 * public String(byte[] bytes):
 * 通过使用平台默认的字符集解码参数中的字节来创建字符串对象。
 * @author Administrator
 *
 */
public class StringDemo2 {

	public static void main(String[] args) {
		//方式一:
		String str1=new String();
		System.out.println(str1);
		//方式二：
		char[] ch={'a','b','c'};
		String str2=new String(ch);
		System.out.println(str2);
		//方式三:
		byte[] by={97,98,99};
		String str3=new String(by);
		System.out.println(str3);
		//方式四:
		String str4="abc";
		System.out.println(str4);
	}
}

5.4.常用方法

public boolean equals(Object anObject):将当前字符串与指定字符串anObject进行比较是否相等。

public boolean equalsIgnoreCase(String anotherString)：将当前字符串与指定字符串anObject进行比较是否相等，忽略大小写。

public boolean startsWith(String prefix):测试当前字符串是否以指定的前缀开始。

public boolean endsWith(String suffix):测试当前字符串是否以指定的后缀结束。

package cn.tedu.String;
/**
 * String类的常用方法：
 * public boolean equals(Object anObject): 将当前字符串与指定字符串anObject进行比较是否相等。
 * 
 * public boolean equalsIgnoreCase(String anotherString)：将当前字符串与指定字符串anObject进行比较是否相等，忽略大小写。
 * 
 * public boolean startsWith(String prefix):测试当前字符串是否以指定的前缀开始。
 * 
 * public boolean endsWith(String suffix):测试当前字符串是否以指定的后缀结束。
 * @author Administrator
 */
public class StringDemo3 {

	public static void main(String[] args) {
		//创建字符串对象
		String s1="hello";
		String s2="hello";
		String s3="HELLO";
		char[] ch={'h','e','l','l','o'};
		String s4=new String(ch);
		String s5=null;
		System.out.println(s1.equals(s2));//true
		System.out.println(s1.equals(s3));//false
		System.out.println(s1.equals(s4));//true
		System.out.println(s1.equals(s5));//false
        //任何一个空对象都不能调用属性和方法否则都会报以下异常
        //java.lang.NullPointerException空指针异常，应该避免。
		//System.out.println(s5.equals(s1));
		System.out.println("------------------");
		System.out.println(s1.equalsIgnoreCase(s2));//true
		System.out.println(s1.equalsIgnoreCase(s3));//true
		System.out.println("------------------");
		String str="Thinking in Java";
		System.out.println(str.startsWith("T"));//true
		System.out.println(str.endsWith("Java"));//true
		System.out.println(str.startsWith("thinking"));//false	
	}
}

5.5.获取功能的方法

public int length():返回此字符串的长度。

public String concat(String str):将指定字符串str连接到当前字符串的末尾。

public char charAt(int index):返回当前字符串中指定索引index处的char字符。

public int indexOf(String str):返回指定字符串str第一次出现在当前字符串的索引位置下标,没有则返回-1。

public String substring(int beginIndex):返回一个子字符串，从当前字符串的beginIdex下标位置开始截取到当前字符串的末尾。

public String substring(int beginIndex,int endIndex):返回一个子字符串，从当前字符串的beginIndex下标位置开始截取到当前字符串的endIndex下标位置结束,包含beginIndex，不包含endIndex。

package cn.tedu.String;
/**
 * 获取功能的方法：
 * public int length():
 * 返回此字符串的长度。
 * public String concat(String str):
 * 将指定字符串str连接到当前字符串的末尾。
 * public char charAt(int index):
 * 返回当前字符串中指定索引index处的char字符。
 * public int indexOf(String str):
 * 返回指定字符串str第一次出现在
 * 当前字符串的索引位置下标,没有则返回-1。
 * public String substring(int beginIndex):
 * 返回一个子字符串，从当前字符串的beginIdex
 * 下标位置开始截取到当前字符串的末尾。
 * public String substring(int beginIndex,int endIndex):
 * 返回一个子字符串，从当前字符串的beginIndex下标位置开始
 * 截取到当前字符串的endIndex下标位置结束,
 * 包含beginIndex，不包含endIndex。
 * 
 * @author Administrator
 *
 */
public class StringDemo5 {

	public static void main(String[] args) {
		//创建字符串对象
		String s="helloworld";
		int length=s.length();
		System.out.println("字符串的长度为:"+length);//字符串的长度为:10
		System.out.println("------------------");
		String s1=s.concat("**hello tedu");
		System.out.println(s1);//helloworld**hello tedu
		System.out.println("------------------");
		System.out.println(s.charAt(0));//h
		System.out.println(s.charAt(9));//d
		System.out.println("------------------");
		System.out.println(s.indexOf("l"));//2
		System.out.println(s.indexOf("owo"));//4
		System.out.println(s.indexOf("ak"));//-1
		System.out.println("------------------");
		System.out.println(s.substring(1));//elloworld
		System.out.println(s.substring(5));//world
		System.out.println("------------------");
		System.out.println(s.substring(4, 7));//owo
		System.out.println(s.substring(5,s.length()));//world		
	}
}

5.6.课堂练习

定义一个方法，将int数组{1,2,3}取出来按照指定格式拼接成一个字符串。

格式：[word1#word2#word3]

结果：[1#2#3]

package cn.tedu.String;
/**
 * 课堂练习：
 *  定义一个方法，将int数组{1,2,3}取出来按照指定格式
 *  拼接成一个字符串。格式：[word1#word2#word3]
 *  [1#2#3]
 * @author Administrator
 *
 */
public class StringDemo6 {

	public static void main(String[] args) {
		//创建int数组
		int[] arr={1,2,3};
		//调用拼接方法
		String s=arrayToString(arr);
		System.out.println("拼接后的字符串为:"+s);
	}
	/**
	 * 字符串拼接的方法
	 * @param arr要做拼接的数组
	 * @return 拼接后的字符串
	 */
	public static String arrayToString(int[] arr){
		String s="[";
		//遍历数组
		for(int i=0;i<arr.length;i++){
			if(i==arr.length-1){
			//到数组的最后一个元素时，
			//就在原有基础上拼接当前元素和]
				s=s.concat(arr[i]+"]");//[1#2#3]
			}else{
		//只要没有到最后一个数组元素，
		//就在原有基础上拼接当前数组元素和#
				s=s.concat(arr[i]+"#");//[1#2#
			}
		}
		return s;
	}
}

5.7.转换功能的方法

public char[] toCharArray():将当前字符串转换为字符数组。

public byte[] getBytes():将当前字符串采用平台默认的字符集编码转换为新的字节数组。

public String replace(CharSequence target, CharSequence replacement):将与target匹配的字符串采用replacement字符串来替换。

package cn.tedu.String;
/**
 * 转换功能的方法：
 * public char[] toCharArray():将当前字符串转换为字符数组。
 * public byte[] getBytes():将当前字符串采用平台默认的字符集编码转换为新的字节数组。
 * public String replace(CharSequence target, CharSequence replacement):将与target匹配的字符串采用replacement字符串来替换。
 * 
 * 
 * @author Administrator
 *
 */
public class StringDemo7 {

	public static void main(String[] args) {
		//创建字符串对象
		String s="abcde";
		//将字符串转换为字符数组
		char[] chs=s.toCharArray();
		//遍历数组
		for (int i = 0; i < chs.length; i++) {
			System.out.println(chs[i]);
		}
		System.out.println("------------------");
		//将字符串转换为字节数组
		byte[] bytes=s.getBytes();
		//遍历数组
		for (int i = 0; i < bytes.length; i++) {
			System.out.println(bytes[i]);
		}
		System.out.println("------------------");
		String str="ittarena ittedu";
		String str1=str.replace("it", "IT");
		System.out.println(str1);
	}
}

小贴士：CharSequence 是一个接口，也是一种引用类型。作为参数类型，可以把String对象传递到方法中。将所有出现的原字符串替换成为新的字符串，返回替换之后的结果新字符串。

5.8.课后作业

统计字符个数

键盘录入一个字符，统计字符串中大写字母、小写字母及数字字符个数。

package cn.tedu.String;

import java.util.Scanner;

/**
 * 统计字符个数
 * 键盘录入一个字符串，统计字符串中大写字母、小写字母及数字字符个数。
 * 
 * @author Administrator
 *
 */
public class HomeWork2 {

	public static void main(String[] args) {
		//键盘录入一个字符串数据
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入一个字符串数据:");
		String str=sc.nextLine();
		//定义三个统计变量，初始化为0
		int bigCount=0;
		int smallCount=0;
		int numberCount=0;
		//遍历字符串，得到每一个字符
		for (int i = 0; i < str.length(); i++) {
			char ch=str.charAt(i);
			//拿字符进行判断
			if(ch>='A'&&ch<='Z') {
				bigCount++;
			}else if(ch>='a'&&ch<='z') {
				smallCount++;
			}else if(ch>='0'&&ch<='9'){
				numberCount++;
			}else {
				System.out.println("该字符"+ch+"非法!");
			}
		}
		System.out.println("大写字符："+bigCount+"个");
		System.out.println("小写字符："+smallCount+"个");
		System.out.println("数字字符："+numberCount+"个");
		sc.close();
	}
}

5.9.分割功能的方法

package cn.tedu.String;
/**
 * 分割功能的方法:
 * public String[] split(String regex):将当前字符串按照给定的regex(规则)拆分为字符串数组。
 * @author Administrator
 *
 */
public class StringDemo8 {

	public static void main(String[] args) {
		//创建字符串对象
		String str="aa%bb%cc";
		//按照|进行拆分
		String[] strArray=str.split("%");//["aa","bb","cc"]
		//遍历拆分后的数组
		for (int i = 0; i < strArray.length; i++) {
			System.out.println(strArray[i]);//aa bb cc
		}
	}
}

6.正则表达式

背景：
实际发过程中，经常需要对字符串数据进行一些复杂的匹配、校验、查找、替换等操作。通过“正则表达式”可以方便的实现字符串的复杂操作。
概述：
正则表达式(Regular Expression)是一组特定字符，组成的一个“规则字符串”，这个“规则字符串”是描述文本规则的工具。正则表达式就是记录文本规则的代码。

6.1.常用正则

正则	说明
[abc]	a、b、c任意一个字符
[^abc]	除了a、b、c以外的任意字符
[a-z]	a到z之间的任意一个字符
[a-z]+	a到z中的一个或者多个字符
[a-zA-Z0-9]	a-z、A-Z、0-9中的任意一个字符
[a-z&&[^bc]]	a-z中除了b和c以外的任意字符
.	表示任意一个字符
\d	表示任意一个数字
\w	表示单词字符相当于[a-zA-Z0-9]
\s	表示空白字符，空格、换行、tab
\D	表示任意一个非数字字符
\W	表示任意一个非单词字符
\S	表示非空白字符
X?	表示0个或1个X字符
X+	表示1个或任意多个X字符
X*	表示0个或任意多个X字符
X{n}	表示n个X字符
X{n,}	表示n到任意多个X字符(大于等于n个X)
X{n,m}	表示n到m个X字符
^	表示字符串的开始
$	表示字符串的结束

String类的比对方法：
public boolean matches(String regex):校验当前字符串是否符合指定正则的规则,符合返回true，否则返回false。

package cn.tedu.Regular;

public class RegDemo1 {

	public static void main(String[] args) {
		String regex1="[abc]";
		String regex2="[^abc]";
		String regex3="[a-z]";
		String regex4="[a-z]+";
		String regex5="[a-zA-Z0-9]";
		String regex6="[a-z&&[^bc]]";
		System.out.println("a".matches(regex1));//true
		System.out.println("a".matches(regex2));//false
		System.out.println("h".matches(regex3));//true
		System.out.println("abcd".matches(regex4));//true
		System.out.println("T9".matches(regex5));//true
		System.out.println("e".matches(regex6));//true
	}
}

package cn.tedu.Regular;

public class RegDemo2 {

	public static void main(String[] args) {
		String regex1="\\w{5}";
		String regex2="\\d{5,}";
		String regex3="[a-zA-Z]{5,8}";
		System.out.println("9aTab".matches(regex1));//true
		System.out.println("123445".matches(regex2));//true
		System.out.println("HelloWorld".matches(regex3));//false
	}
}

String类替换方法：
public String replaceAll (String regex, String replacement)：将当前字符串按照匹配的正则表达式regex替换为replacement。

package cn.tedu.Regular;
/**
 * 检索邮政编码：
 * -规则为6位的数字
 * -规则1：[0-9][0-9][0-9][0-9][0-9][0-9]
 * -规则2：\d\d\d\d\d\d
 * -规则3：\d{6}
 * 
 *  边界匹配：
 *  ^代表字符串开始
 *  $表示字符串结束
 *  
 *  ^\w+
 *  \w+$
 * @author Administrator
 *
 */
public class RegDemo3 {

	public static void main(String[] args) {
		//将str中的开头或结尾的数字替换为“数字”二字。
		String str="22abc123bcd45ef6g7890";//数字abc123bcd45ef6g数字
		String regex="^\\d+|\\d+$";
		str=str.replaceAll(regex, "数字");
		System.out.println(str);	
	}
}

6.2.分组

()圆括号表示分组，可以将一系列正则表达式看做一个整体，分组中可以使用“|”表示“或”的关系。

6.3.课堂案例

1.检索手机号码：
+86 18338389436
—： +86 +0086 可有可无
—： +86与号码之间的空格可以没有或者有多个
—：电话号码为11位数字 \d{11}
正则： (+86|+0086)?\s*\d{11}

package cn.tedu.Regular;

public class RegDemo4 {

	public static void main(String[] args) {
	String tel="18338389436";
	String regex="(\\+86|\\+0086)?\\s*\\d{11}";
	System.out.println(tel.matches(regex));	
	}
}

2.检索邮箱：
6-32位的字母或数字 3077003875@qq.com xamayfa@tedu.cn xamayfa@163.cn
正则：[a-zA-Z0-9]{6,32} \w{6,32}@\w+.(com|cn)

package cn.tedu.Regular;

public class RegDemo5 {

	public static void main(String[] args) {
	String email="xamayfa@163.cn";
	String regex="\\w{6,32}@\\w+\\.(com|cn)";
	System.out.println(email.matches(regex));
	}
}

3.和谐用语：
分组(regex1|regex2|regex3)

package cn.tedu.Regular;
/**
 * 和谐用语
 * 友情提示：
 *    文明用语，以下仅为学习，请勿模仿!
 * @author Administrator
 *
 */
public class RegDemo6 {

	public static void main(String[] args) {
		//定义正则
		String regex="(tmb|wqnmlgb|nc|sb|dsb)";
		String message=
		"ca你个sb!你怎么这么的nc！tmb！wqnmlgb!你个dsb！";
		message=message.replaceAll(regex, "***");
		System.out.println(message);
	}
}

4.拆分字符串：
String类分割功能的方法:
public String[] split(String regex):将当前字符串按照给定的regex(规则)拆分为字符串数组。

package cn.tedu.Regular;

import java.util.Arrays;

/**
 * 分割功能的方法:
 * public String[] split(String regex):
 * 将当前字符串按照给定的regex(规则)拆分为字符串数组。
 * @author Administrator
 *
 */
public class RegDemo7 {

	public static void main(String[] args) {
	//按照空格拆分字符串
	String str="java c++ python php c# .net";
	String[] strAr=str.split("\\s");
//	for (int i = 0; i < strAr.length; i++) {
//		System.out.println(strAr[i]);
//	}
	System.out.println(Arrays.toString(strAr));
	//按照+ - =符号拆分
	 String line="100+200-150=150";
	 String[] lined=line.split("[\\+\\-=]");//  \\D    (\\+|-|=)   
	 System.out.println(Arrays.toString(lined));
	}
}

7.Arrays类

7.1.知识概述

java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单。

7.2.操作数组的方法

public static String toString(int[] a)：返回指定数组内容的字符串表示形式。
public static void sort(int[] a)：对指定的 int 型数组按数字升序进行排序。

package cn.tedu.Arrays;

import java.util.Arrays;

/**
 * 知识概述：
 * 	java.util.Arrays 此类包括用来操作数组的各种方法，比如元素搜素或排序等，其所有方法都为静态方法，
 * 所以调用起来非常简单。
 *操作数组的常用方法：
 *public static String toString(int[] a):返回指定int数组a中元素的字符串表现形式。
 *	
 * @author Administrator
 *
 */
public class ArraysDemo1 {

	public static void main(String[] args) {
		//定义int数组
		int[] arr1= {2,34,35,24,57,8,9};
		System.out.println(arr1);//[I@7852e922
		String s1=Arrays.toString(arr1);
		System.out.println(s1);//[2, 34, 35, 24, 57, 8, 9]
		//定义Double数组
		double[] arr2= {5.6,7.8,10.6,9.2};
		System.out.println(arr2);
		String s2=Arrays.toString(arr2);//[D@4e25154f
		System.out.println(s2);//[5.6, 7.8, 10.6, 9.2]
	}
}

package cn.tedu.Arrays;

import java.util.Arrays;

/**
 * 知识概述：
 * 	java.util.Arrays 此类包括用来操作数组的各种方法，比如元素搜素或排序等，其所有方法都为静态方法，
 * 所以调用起来非常简单。
 *操作数组的常用方法：
 *public static String toString(int[] a):返回指定int数组a中元素的字符串表现形式。
 *public static void sort(int[] a):对指定int数组a按照元素大小进行升序排序。
 *	
 * @author Administrator
 *
 */
public class ArraysDemo2 {

	public static void main(String[] args) {
		//定义int数组
		int[] arr= {24,7,5,48,4,46,35,11,6,2};
		System.out.println("排序前："+Arrays.toString(arr));
		//升序排序
		Arrays.sort(arr);
		System.out.println("排序后："+Arrays.toString(arr));
	}
}

7.3.课堂练习

请使用Arrays相关的API方法，将一个随机字符串中的所有字符升序排序，并倒序打印。

package cn.tedu.Arrays;

import java.util.Arrays;

/**
 * 课堂练习：
 *  请使用Arrays相关的API方法，将一个随机字符串中的所有字符升序排序，并倒序打印。
 * @author Administrator
 *
 */
public class ArraysDemo3 {

	public static void main(String[] args) {
		//定义随机字符串
		String line="ayuoeljkhyekc";
		//将字符串转换为字符数组
		char[] chars=line.toCharArray();
		//升序排序
		Arrays.sort(chars);
		//反向遍历打印
		for (int i = chars.length-1; i >=0; i--) {
			System.out.print(chars[i]+" ");//y y u o l k k j h e e c a 
		}
	}
}

8.StringBuilder类

8.1.课堂提问

字符串拼接问题效率问题？

package cn.tedu.StringBuilder;
/**
 *    字符串做拼接操作的效率？ 
 *    "Hello"  "World"   "HelloWorld" 产生是三个对象。
 * @author Administrator
 *
 */
public class StringBuilderDemo1 {

	public static void main(String[] args) {
		String s="Hello";
		//s+="World";
		s=s+"World";
		System.out.println(s);
	}
}

在API中对String类有这样的描述：字符串是常量，它们的值在创建后不能被更改。
根据这句话分析我们的代码，其实总共产生了三个字符串，即"Hello"、“World"和"HelloWorld”。引用变量s首先指向Hello对象，最终指向拼接出来的新字符串对象，即HelloWord 。
由此可知，如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。为了解决这一问题，可以使用java.lang.StringBuilder类。

8.2.知识概述

StringBuilder和String 类不同的是， StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容，StringBuilder 类在 Java 5 中被提出。(序列：被排成一列的对象)
StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。
它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。原理如下图所示：(默认16字符空间，超过自动扩充)

8.3.构造方法

根据StringBuilder的API文档，常用构造方法有2个：
public StringBuilder()：构造一个空的StringBuilder容器。
public StringBuilder(String str)：构造一个StringBuilder容器，并将字符串添加进去。
public StringBuilder(int capacity) : 构造一个StringBuilder容器，并自定义容量。

package cn.tedu.StringBuilder;
/**
 *  
 * @author Administrator
 *
 */
public class StringBuilderDemo2 {

	public static void main(String[] args) {
		//创建对象方式一：
		StringBuilder s1=new StringBuilder();
		System.out.println(s1);//空串
		System.out.println(s1.capacity());//16
		s1.append("Hello");//字符串拼接
		System.out.println(s1);//Hello
		s1.append("World");
		System.out.println(s1);//HelloWorld
		System.out.println("---------------");
		//创建对象方式二：
		StringBuilder s2=new StringBuilder("tedu");
		System.out.println(s2);//tedu
		System.out.println(s2.capacity());//20
		//创建对象方式三：
		StringBuilder s3=new StringBuilder(100);
		System.out.println(s3.capacity());//100
	}
}

备注：当使用无参构造创建对象时，默认容量是16 超出后会自动扩容一倍当使用String参数的构造时，容量为 16 加上字符串参数的长度。

8.4.常用方法

public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。
public String toString()：将当前StringBuilder对象转换为String对象。
public int capacity()：查看底层数组的默认容量16

package cn.tedu.StringBuilder;
/**
 * 测试String类和StringBuillder是否产生新的对象问题？
 * equals()方法：比较字符串的内容是否相等。
 * ==：比较两个值相等或对象是否是同一个。
 * @author Administrator
 *
 */
public class StringBuilderDemo3 {

	public static void main(String[] args) {
		String str1="Hello";
		String str2=str1+"Kitty";
		System.out.println(str1==str2);//false
		
		StringBuilder str3=new StringBuilder("Hello");
		StringBuilder str4=str3.append("Kitty");
		StringBuilder str5=new StringBuilder("HelloKitty");
		StringBuilder str6=new StringBuilder("HelloKitty");
		System.out.println(str3==str4);//true
		System.out.println(str4==str5);//false
		System.out.println("----------------");
		StringBuilder s=new StringBuilder();
//		s.append("hello");
//		s.append(100);
//		s.append(true);
		//链式编程
		s.append("hello").append(100).append(true).append('a').append(0.5);
		System.out.println(s);

	}
}

package cn.tedu.StringBuilder;
/**
 * 常用方法：
 *  public int capacity()：查看底层数组的默认容量16      扩容：34  70  142
 *  public StringBuilder append(String str):对当前字符串末尾追加str字符串
 *  public String toString():将当前StringBuilder类型的对象转换为String对象.
 * @author Administrator
 *
 */
public class StringBuilderDemo4 {

	public static void main(String[] args) {
		//链式创建
		StringBuilder s=new StringBuilder("Hello").append("World").append("Java");
		//调用方法
		String str=s.toString();
		System.out.println(str);//HelloWorldJava
	}
}

9.StringBuffer类

9.1.知识概述

线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。

9.2.构造方法

public StringBuffer():构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
public StringBuffer(int capacity):构造一个不带字符，但具有指定初始容量的字符串缓冲区。
public StringBuffer(String str): 构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。

9.3.常用方法

StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。
public synchronized StringBuffer append(String str):在当前StringBuffer字符串末尾追加指定字符串str，此方法为线程安全的方法。
public synchronized StringBuffer insert(int offset, String str):在当前StringBuffer字符串的指定位置offset处，插入字符串str。

package cn.tedu.StringBuffer;
/**
 * 一.知识概述：
 * 线程安全的可变字符串，相当于String字符串的缓冲区。
 *二.构造方法：
 * public StringBuffer():构造创建一个不带字符的字符串缓冲区，其内部字符数组默认容量16个。
 * public StringBuffer(int capactiy):构造创建一个不带字符，但具有指定初始化容量的字符串缓冲区。
 * public StringBuffer(String str):构造创建一个字符串缓冲区，并将其指定内容str初始化为字符串内容。
 * 
 *三：常用方法:
 *public synchronized StringBuffer append(String str):在当前StringBuffer字符串末尾追加指定字符串str，此方法为线程安全的方法。
 *public synchronized StringBuffer insert(int offset, String str):在当前StringBuffer字符串的指定位置offset处，插入字符串str。
 *
 *StringBuilder和StringBuffer的区别:
 *1.StringBuilder和StringBuffer都是可变字符串序列。
 *2.StringBuffer在多线程下同步进行,其所有的方法使用synchronized关键字修饰，故其线程安全性比StringBuider高，但其执行效率相对于StringBuilder要慢。
 *3.StringBuilder在JDK1.5中引入，非同步执行，线程不安全，执行效率高于StringBuffer，但是在单线程中操作时优先使用此类。
 * 
 * @author Administrator
 *
 */
public class StringBufferDemo1 {

	public static void main(String[] args) {
		//创建方式一:
		StringBuffer str1=new StringBuffer();
		System.out.println(str1.capacity());//16
		//创建方式二:
		StringBuffer str2=new StringBuffer(50);
		System.out.println(str2.capacity());//50
		//创建方式三：
		StringBuffer str3=new StringBuffer("Hello");
		System.out.println(str3.capacity());//21
		System.out.println("---------------");
		System.out.println(str3.append("Kitty"));
		System.out.println("---------------");
		str3.insert(5,"World");
		System.out.println(str3);
	}
}

9.4.常见面试题

StringBuffer与StringBuilder的区别?
StringBuffer和StringBuilder都是可变字符序列，
StringBuffer在多线程下同步进行，其所有方法使用synchronized关键字修饰，故其线程安全性比StringBuilder高，但执行效率相对低。
StringBuilder在JDK5中引入，非同步执行，线程不安全，执行效率比StringBuffer高，在单线程中操作时优先使用此类。

10.System类

10.1.课堂提问

使用到过System类中哪些方法？在哪里用过？

System.out.println();

10.2.知识概述

java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作。

10.3.常用方法

public static long currentTimeMillis()：获取当前系统时间与1970年01月01日00:00点之间的毫秒差值。
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。

package cn.tedu.System;
/**
 *一.知识概述：
 * java.lang.System类中提供了大量的静态方法，
 * 可以获取与系统相关的信息或系统级的操作。
 *二.常用方法：
 *  public static native long currentTimeMillis():返回当前系统时间的毫秒值。
 *  
 *三.课堂练习：
 *   计算for循环打印数字1-10000这个过程使用了多少毫秒时间？
 *   
 * @author Administrator
 *
 */
public class SystemDemo1 {

	public static void main(String[] args) {
//		System.out.println("Hello");
//		System.err.println("World");
		//返回当前系统时间的毫秒值 1s=1000ms
		//距离1970.1.1 08:00:00:00
		long time=System.currentTimeMillis();
		System.out.println(time);
	}
}

package cn.tedu.System;

import java.util.Arrays;

/**
 * public static native void arraycopy(Object src,  int  srcPos,Object dest, int destPos,int length):将数组中的指定数据拷贝到另外一个数组。
 * Object src源数组
 * int  srcPos 源数组的下标(索引)起始位置
 * Object dest 目标数组
 * int destPos 目标数组下标(索引)起始位置
 * int length 在源数组中复制的元素个数
 * 练习：将src数组中前三个元素，复制到dest目标数组的前三个位置上，复制后src数组[1,2,3,4,5],dest数组[1,2,3,9,10]
 * @author Administrator
 *
 */
public class SystemDemo3 {

	public static void main(String[] args) {
		int[] src= {1,2,3,4,5};//源数组
		int[] dest= {6,7,8,9,10};//目标数组
		System.arraycopy(src, 0, dest, 0, 3);
		System.out.println(Arrays.toString(src));
		System.out.println(Arrays.toString(dest));

	}

}

10.4.课堂练习

计算for循环打印数字1-10000这个过程使用了多少毫秒时间？

package cn.tedu.System;
/**
 *一.知识概述：
 * java.lang.System类中提供了大量的静态方法，
 * 可以获取与系统相关的信息或系统级的操作。
 *二.常用方法：
 *  public static native long currentTimeMillis():返回当前系统时间的毫秒值。
 *  
 *三.课堂练习：
 *   计算for循环打印数字1-10000这个过程使用了多少毫秒时间？
 *   扩展练习：
 *   StringBuilder和StringBuffer,StringBuilder的效率高于StringBuffer。
 *   使用append()追加10000次，查看谁的效率高。
 *   
 * @author Administrator
 *
 */
public class SystemDemo2 {

	public static void main(String[] args) {
		//获取此时距离1970.1.1的毫秒值
		long start=System.currentTimeMillis();
		for (int i = 1; i <=10000; i++) {
			System.out.println(i);
		}
		//获取此时距离1970.1.1的毫秒值
		long end=System.currentTimeMillis();
		System.out.println("共耗时："+(end-start)+"毫秒!");

	}
}

扩展练习：
StringBuilder和StringBuffer,StringBuilder的效率高于StringBuffer。
使用append()追加10000次，查看谁的效率高。

10.5.课后作业

将src数组中前3个元素，复制到dest数组的前3个位置上复制元素前：src数组元素[1,2,3,4,5]，dest数组元素[6,7,8,9,10]复制元素后：src数组元素[1,2,3,4,5]，dest数组元素[1,2,3,9,10]

import java.util.Arrays;

public class SystemArrayCopy {
    public static void main(String[] args) {
        int[] src = new int[]{1,2,3,4,5};
        int[] dest = new int[]{6,7,8,9,10};
        System.arraycopy( src, 0, dest, 0, 3);
        /*代码运行后：两个数组中的元素发生了变化
         src数组元素[1,2,3,4,5]
         dest数组元素[1,2,3,9,10]
        */
    }
}

11.Object类

11.1.知识概述

java.lang.Object类是Java语言中的根类，即所有类的父类。Object中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。
如果一个类没有特别指定父类，那么默认则继承自Object类。例如：

public class MyClass /*extends Object*/ {
    // ...
}

根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个。

11.2.常用方法

public String toString():返回当前对象的字符串表示形式。
toString方法表示对象的字符串形式，字符串的内容为对象的类型+@+内存地址值由于toString方法返回的结果是内存地址，实际开发中会按照对象的属性得到相应的字符串形式。
public boolean equals(Object obj):比较当前对象与指定对象obj是否是同一个，Object中的equals中使用==判断，只要不是同一个对象则必然为false。
一般情况下Object中的equals()方法意义不大，我们会重写
equals()方法，一般遵循以下规则：
1.判断两个对象地址是否相同。
2.判断对象是否为空。
3.判断两个对象的创建类型是否一致。
4.判断两个对象的属性值是否一致。
public native int hashCode():返回对象的哈希值得十进制，哈希码是一串32位的二进制数据，对对象的一个标号。
如果两个对象做equals比较如果相等，哈希码必须一致。哈希码一致equals比较两个对象不一定为true
protected native Object clone():克隆对象。
克隆对象后会产生新的对象，这个新对象和原对象地址不同，但是属性值相同。一个对象要想被克隆，那么这个类必须实现Cloneable接口，这个接口中没有任何的属性和方法，仅仅用于标识这个类产生的对象可以被克隆。
protected void finalize():通知GC垃圾回收机制，回收垃圾对象，但是也不一定会立马执行回收，并且只会回收当前对象，不会回收其他对象。
public final native Class<?> getClass()：返回当前对象的类型。

package cn.tedu.Object;
/**
 * 一.知识概述
 * java.lang.Object类是Java语言中的根类，即所有类的父类。Object类中描述的所有方法子类都可以使用。
 * 所有类在实例化过程中最终找的都是顶级父类Object。
 * 如果一个类没有特定指定父类，那么默认则继承Object
 *二.常用方法
 * public String toString():返回当前对象的字符串表示形式。
 * toString方法表示对象的字符串形式，字符串的内容为对象的类型+@+内存地址值
 *  由于toString方法返回的结果是内存地址，实际开发中会按照对象的属性得到相应的字符串形式。
 *  public boolean equals(Object obj):
 *  比较当前对象与指定对象obj是否是同一个，
 *  Object中的equals中使用==判断，
 *  只要不是同一个对象则必然为false。
 *  一般情况下Object中的equals()方法意义不大，我们会重写
 *  equals()方法，一般遵循以下规则：
 *  1.判断两个对象地址是否相同。
 *  2.判断对象是否为空。
 *  3.判断两个对象的创建类型是否一致。
 *  4.判断两个对象的属性值是否一致。
 * public native int hashCode():返回对象的哈希值得十进制，哈希码是一串32位的二进制数据，对对象的一个标号。
 * 如果两个对象做equals比较如果相等，哈希码必须一致。哈希码一致equals比较两个对象不一定为true
 * 
 * @author Administrator
 *
 */
public class ObjectDemo1 {

	public static void main(String[] args) {
		ObjectDemo1 demo=new ObjectDemo1();
		System.out.println(demo.toString());
		int[] arr= {1,2,3};
		System.out.println(arr.toString());
		ObjectDemo1 demo1=new ObjectDemo1();
		System.out.println(demo.equals(demo1));
		System.out.println(demo==demo1);
	}
}

package cn.tedu.Object;


public class ObjectDemo2 implements Cloneable {
	int i;
	public static void main(String[] args) throws Throwable  {
		ObjectDemo2 o1=new ObjectDemo2();
		o1.i=10;
		//克隆对象
		ObjectDemo2 o2=(ObjectDemo2)o1.clone();
		System.out.println(o1==o2);//false
		o1.finalize();//通知GC尽快来回收当前对象。
		Object o3=new String("abc");
		System.out.println(o1.getClass());//class cn.tedu.Object.ObjectDemo2
		System.out.println(o3.getClass());//class java.lang.String
	}
}

package cn.tedu.Object;

public class Person {
	private String name;
	private int 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;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
//	@Override
//	public boolean equals(Object obj) {
//		//如果对象是同一个直接返回true
//		if(this==obj) {
//			return true;
//		}
//		//如果obj为空，或者this和obj对象类型不同直接返回false
//		if(obj==null||this.getClass()!=obj.getClass()) {
//			return false;
//		}
//		Person person=(Person)obj;
//		return age==person.age&&name==person.name;
//	}
	
	public static void main(String[] args) {
		Person p1=new Person();
		p1.setName("鲁班七号");
		p1.setAge(8);
		System.out.println(p1.toString());
		Person p2=new Person();
		p2.setName("鲁班七号");
		p2.setAge(8);
		System.out.println(p1==p2);//false
		System.out.println(p1.equals(p2));//false
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (this.getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
}

11.3.常见面试题

==与equals的区别：
1.语法：==关系运算符，equals()是方法。
2.运行：判断基本数据类型时判断的是数值是否相等，判断引用数据类型是两个对象是否是同一个。
equals如果不重写，则是比较两个对象是否是同一个，重写后是比较两个对象的内容是否相等。

12.Objects

java.util.Objects类，那么这个类是什么呢？
在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。
在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法如下：
public static boolean equals(Object a, Object b):判断两个对象是否相等。
我们可以查看一下源码，学习一下：

public static boolean equals(Object a, Object b) {  
    return (a == b) || (a != null && a.equals(b));  
}

package cn.tedu.Objects;

import java.util.Objects;

/**
 * java.util.Objects在JDK1.7中添加的一个工具类。它提供了一些方法来操作对象，这些方法由静态方法组成并且这些方法都是空指针安全的方法。
 * 
 * public static boolean equals(Object a, Object b)
 * @author Administrator
 *
 */
public class ObjectsDemo {

	public static void main(String[] args) {
		ObjectsDemo demo1=null;
		ObjectsDemo demo2=new ObjectsDemo();
		//System.out.println(demo1.equals(demo2));//java.lang.NullPointerException 空对象的引用调用属性或者方法就会产生空指针异常(应该避免)。
		System.out.println(Objects.equals(demo1, demo2));
	}
}

12.包装类

12.1.知识概述

Java中两种数据类型，基本数据类型和引用数据类型，基本类型执行效率高，然而很多情况下，基本数据类型中无法调用自己的方法对其数据进行一系列相关的操作，所以需要创建对象，对象可以定义许多方法和功能，所以Java语言的缔造者定义了与基本数据类型相对应的包装类，所有基本类型都有一个与之对应的类，即包装类（wrapper）。如果我们想要基本类型像对象一样进行相关操作，就可以使用基本类型对应的包装类。

12.2.基本类型与包装类

基本类型	包装类	父类
byte	java.lang.Byte	java.lang.Number
short	java.lang.Short	java.lang.Number
char	java.lang.Character	java.lang.Object
int	java.lang.Integer	java.lang.Number
long	java.lang.Long	java.lang.Number
float	java.lang.Float	java.lang.Number
double	java.lang.Double	java.lang.Number
boolean	java.lang.Boolean	java.lang.Object
void	java.lang Void	java.lang.Object

备注:在API的注释中对基本数据注释中提到primitive type单词
void在官方中并没有明确提出是基本数据类型，但在《Thinking in
Java》被称为Java的圣经中提到了void为基本数据类型。包装类是不可变类，在构造了包装类对象后，不允许更改包装在其中的值；包装类是final修饰的，不可改变，在构造了包装类对象后，不允许改变包装在其中的值，且不能定义他们的子类。

12.3.Number及其主要方法

Number的子类必须提供将表示的数值转换为byte，double，float，int，long和short的方法：
doubleValue（）以double形式返回指定的数值。
intValue（）以int形式返回指定的数值。
floatValue（）以float形式返回指定的数值。
longValue( ) 以 long 形式返回指定的数值。
byteValue( ) 以 byte 形式返回指定的数值。

package cn.tedu.Wrapper;
/**
 * byteValue() 以byte形式返回指定数值
 * shortValue() 以short形式返回指定数值
 * intValue() 以int形式返回指定数值
 * longValue() 以long形式返回指定数值
 * doubleValue() 以double形式返回指定数值
 * floatValue() 以float形式返回指定数值
 * 
 * @author Administrator
 *
 */
public class WrapperDemo1 {

	public static void main(String[] args) {
		Number a=123;
		Number b=123.45;
		System.out.println(a.getClass().getName());//java.lang.Integer
		System.out.println(b.getClass().getName());//java.lang.Double
		
		int intvalue=a.intValue();
		System.out.println(intvalue);//123
		
		double doublevalue=a.doubleValue();
		System.out.println(doublevalue);//123.0
		
		intvalue=b.intValue();
		System.out.println(intvalue);//123
		doublevalue=b.doubleValue();
		System.out.println(doublevalue);//123.45	
	}
}

12.4.Integer常用功能

该类提供了多个方法，能在int类型和String类型之间互相转换。
1.字段摘要(常量)
static int MAX_VALUE 值为 2^31 - 1的常量，表示int类型能表示的最大值
static int MIN_VALUE 值为 - 2^31 的常量，表示int类型能表示的最小值
-2147483648——2147483647
2.查看构造方法
public Integer(int value)：
构造一个Integer 对象，它表示指定的 int 值。
public Integer(String s):构造一个Integer 对象，它表示 String 参数所指示的 int 值。

注意：如果 String 不包含可解析的整数抛出NumberFormatException数字格式异常

2.常用方法
public static int parseInt(String s) ：将字符串参数作为十进制整数进行解析转换。

package cn.tedu.Wrapper;
/**
 * 知识概述：
 * java.lang.Integer 类为int类型的包装类。
 * 该类提供了多个方法，能在int类型和String类型之间相互转换。
 * 常量：
 *  public static final int MIN_VALUE 表示int类型最小值
 *  public static final int MAX_VALUE 表示int类型最大值
 * 构造方法：
 * public Integer(int value)：构造一个Integer对象，表示指定的int值
 * public Integer(String s):构造一个Integer对象，表示String参数的int值
 * 常用方法：
 * public static int parseInt(String s)：将字符串参数s转换为int类型
 * 
 * @author Administrator
 *
 */
public class WrapperDemo2 {

	public static void main(String[] args) {
		//int类型的最小值
		System.out.println(Integer.MIN_VALUE);//-2147483648
		//int类的最大值
		System.out.println(Integer.MAX_VALUE);//2147483647
		//创建Integer对象
		Integer a=new Integer(100);
		System.out.println(a);//100
		//创建Integer对象
		Integer b=new Integer("200");
		System.out.println(b);//200
		//将字符串转换为int类型
		String s="123";
		System.out.println(Integer.parseInt(s));//123
		//java.lang.NumberFormatException 数字格式转换异常
		String s1="壹佰贰拾叁";
		System.out.println(Integer.parseInt(s1));
	}
}

12.5.Double常用功能

在Double类的对象中包装一个基本类型double的值
1.查看构造方法
public Double(double value) throws NumberFormatException：构造一个Double对象，它表示指定的 double值。
public Double(String s) throws NumberFormatException：构造一个Double对象，它表示 String 参数所指示的 double值。
2.常用方法
public double doubleValue()：返回此Double对象的double值。
public static double parseDouble(String s)：返回一个新的double值，该值被初始化为用指定的String表示的值。

package cn.tedu.Wrapper;
/**
 * 知识概述:java.lang.Double 基本数据类型double对应的包装类。
 * 在Double类中包装一个基本数据类型的double值。
 * 构造方法:
 *  public Double(double value):构造一个Double对象，表示指定的double值。
 *  public Double(String s)：构造一个Double对象，表示String参数表示的double值。
 * 常用方法：
 *  public static double parseDouble(String s)：返回String参数s对于的double值
 * 
 * @author Administrator
 *
 */
public class WrapperDemo3 {

	public static void main(String[] args) {
		//创建Double对象
		Double d1=new Double(100.45);
		System.out.println(d1);//100.45
		Double d2=new Double("120.65");
		System.out.println(d2);//120.65
		//将字符串转换为double
		String s1="12345.25";
		System.out.println(Double.parseDouble(s1));//12345.25
		String s2="壹佰贰拾叁点贰伍";
		System.out.println(Double.parseDouble(s2));
	}
}

12.6.装箱与拆箱

从Java 5.0版本以后提供的编译器在编译期预处理的功能。
基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：
装箱：从基本类型转换为对应的包装类对象。
拆箱：从包装类对象转换为对应的基本类型。
在这里插入图片描述

package cn.tedu.Wrapper;


/**
 * 从Java 5.0版本以后提供的编译器在编译期预处理的功能。
 * 基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：
 * 
 * 装箱：从基本类型转换为对应的包装类对象。
 * 拆箱：从包装类对象转换为对应的基本类型。
 * @author Administrator
 *
 */
public class WrapperDemo4 {

	public static void main(String[] args) {
		//装箱
		Integer a1=100;//Integer.valueOf(100)
		Integer a2=200;//Integer.valueOf(200)
		//拆箱
		Integer a4=new Integer(50);
		int a5=a4;//a4.intValue()
		//先拆箱再装箱
		Integer a3=a1+a2;	
	}
}

麦子程序

关注

3
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
JavaSE

Java高级开发1.API概述1.1.知识概述API(Application Programming Interface),应用程序编程接口。JavaAPI是提供给开发者的查询手册，是JDK中提供给我们使用类的说明文档。这些类将底层的代码进行了封装，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。所以我们可以通过查询API手册的方式，来学习Java类库中提供的类，并得知如何使用它们。1.2.API手册使用步骤1.打开帮助文档。2.点击显示，点击索引，找打输入框。3.要找那个类或接口
复制链接

扫一扫