---恢复内容开始---

Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。所有类在创建对象的时候，最终找的父类就是Object。

* String toString()  : 返回该对象的字符串表示

*  return getClass().getName() + "@" + Integer.toHexString(hashCode());

*  getClass():返回一个字节码对象

*  Integer.toHexString():返回指定参数的十六进制字符串形式

*  hashCode()：返回该对象的哈希码值(内部地址)

重写equals()方法

1@Override 2 public booleanequals(Object obj) {3 //提高效率

4 if (this ==obj)5 return true;6

7 if (obj == null)8 return false;9 //提高健壮性

10 if (getClass() !=obj.getClass())11 return false;12

13 //向下转型

14 Person other =(Person) obj;15

16 if (age !=other.age)17 return false;18 if (name == null) {19 if (other.name != null)20 return false;21 } else if (!name.equals(other.name))22 return false;23 return true;24 }

返回两个数中间的随机数:

1         int number = (int) (Math.random() * (end - start + 1)) + start;

2         return number;

* Random:产生随机数的类

*

* 构造方法：

* public Random():没有给种子，用的是默认种子，是当前时间的毫秒值

* public Random(long seed):给出指定的种子

*

* 给定种子后，每次得到的随机数是相同的。

*

* 成员方法：

* public int nextInt()：返回的是int范围内的随机数

* public int nextInt(int n):返回的是[0,n)范围的内随机数

1 //创建对象

2 //Random r = new Random();

3 Random r = new Random(1111);4

5 for (int x = 0; x < 10; x++) {6 //int num = r.nextInt();

7 int num = r.nextInt(100) + 1;8System.out.println(num);9 }

* System:包含一些有用的类字段和方法。它不能被实例化

* static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

* 复制数组

* 参数1：源数组

* 参数2：源数组的起始索引位置

* 参数3：目标数组

* 参数4：目标数组的起始索引位置

* 参数5：指定接受的元素个数

1 //定义数组

2 int[] arr = { 11, 22, 33, 44, 55};3 int[] arr2 = { 6, 7, 8, 9, 10};4

5 //请大家看这个代码的意思

6 System.arraycopy(arr, 1, arr2, 2, 2);7

8System.out.println(Arrays.toString(arr));9 System.out.println(Arrays.toString(arr2));

*  static long currentTimeMillis() :以毫秒值返回当前系统时间

*  这个毫秒的时间是相对时间，相对于1970-1-1 00:00:00 ： 0

1 　　long start =System.currentTimeMillis();2 for (int i = 0; i < 100000; i++) {3System.out.println(i);4}5 long end =System.currentTimeMillis();6 System.out.println(end - start);

static void exit(int status)

终止当前正在运行的 Java 虚拟机

static void gc()

运行垃圾回收器

* BigInteger:可以让超过Integer范围内的数据进行运算

* public BigInteger add(BigInteger val):加

* public BigInteger subtract(BigInteger val):减

* public BigInteger multiply(BigInteger val):乘

* public BigInteger divide(BigInteger val):除

* public BigInteger[] divideAndRemainder(BigInteger val):返回商和余数的数组

* 因为float类型的数据存储和整数不一样导致的。它们大部分的时候，都是带有有效数字位。由于在运算的时候，float类型和double很容易丢失精度，演示案例。所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal

*

* BigDecimal类：不可变的、任意精度的有符号十进制数,可以解决数据丢失问题。

* 构造方法：

* public BigDecimal(String val)

*

* public BigDecimal add(BigDecimal augend)

* public BigDecimal subtract(BigDecimal subtrahend)

* public BigDecimal multiply(BigDecimal multiplicand)

* public BigDecimal divide(BigDecimal divisor)

* public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode):商，几位小数，如何舍取

System.out.println("divide:" +

bd7.divide(bd8, 8, BigDecimal.ROUND_HALF_UP));

* Date: 表示特定的瞬间，精确到毫秒，他可以通过方法来设定自己所表示的时间，可以表示任意的时间

*

System.currentTimeMillis():返回的是当前系统时间，1970-1-1至今的毫秒数

*

* 构造方法：

*

Date() ：创建的是一个表示当前系统时间的Date对象

Date(long

date) ：根据"指定时间"创建Date对象

* public long getTime():获取时间，以毫秒为单位

* public void setTime(long time):设置时间

*

* 从Date得到一个毫秒值

* getTime()

* 把一个毫秒值转换为Date

* 构造方法

* setTime(long time)

1 Date d = new Date();//默认当前系统时间

2 //d.setTime(1000 * 60 * 60 * 24 * 2);

3System.out.println(d.toLocaleString());4 System.out.println(d.getTime());//172800000

5

6

7 d.setTime(172800000L);8 System.out.println(d.toLocaleString());

* Date -- String(格式化)

* public final String format(Date date)

*

* String -- Date(解析)

* public Date parse(String source)

*

* DateForamt:可以进行日期和字符串的格式化和解析，但是由于是抽象类，所以使用具体子类SimpleDateFormat。

*

* SimpleDateFormat的构造方法：

* SimpleDateFormat():默认模式

* SimpleDateFormat(String pattern):给定的模式

* 这个模式字符串该如何写呢?

* 通过查看API，我们就找到了对应的模式

* 年 y

* 月 M

* 日 d

* 时 H

* 分 m

* 秒 s

*

* 2014年12月12日 12:12:12

1 //Date -- String

2 //创建日期对象

3 Date d = newDate();4 //创建格式化对象

5 //SimpleDateFormat sdf = new SimpleDateFormat();

6 //给定模式

7 SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");8 //public final String format(Date date)

9 String s =sdf.format(d);10 System.out.println(s);

1 //String -- Date

2 String str = "2008-08-08 12:12:12";3 //在把一个字符串解析为日期的时候，请注意格式必须和给定的字符串格式匹配

4 SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");5 Date dd =sdf2.parse(str);6 System.out.println(dd);

Calener类用法:

* Calendar:它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段(例如获得下星期的日期)提供了一些方法。

*

* public int get(int field):返回给定日历字段的值。日历类中的每个日历字段都是静态的成员变量，并且是int类型。

1 //其日历字段已由当前日期和时间初始化：

2 Calendar rightNow = Calendar.getInstance(); //子类对象3

4 //获取年

5 int year =rightNow.get(Calendar.YEAR);6 //获取月

7 int month =rightNow.get(Calendar.MONTH);8 //获取日

9 int date =rightNow.get(Calendar.DATE);10

11 System.out.println(year + "年" + (month + 1) + "月" + date + "日");

1 //获取当前的日历时间

2 Calendar c =Calendar.getInstance();3

4 //获取年

5 int year =c.get(Calendar.YEAR);6 //获取月

7 int month =c.get(Calendar.MONTH);8 //获取日

9 int date =c.get(Calendar.DATE);10 System.out.println(year + "年" + (month + 1) + "月" + date + "日");11

12

13 //5年后的10天前

14 c.add(Calendar.YEAR, 5);15 c.add(Calendar.DATE, -10);16 //获取年

17 year =c.get(Calendar.YEAR);18 //获取月

19 month =c.get(Calendar.MONTH);20 //获取日

21 date =c.get(Calendar.DATE);22 System.out.println(year + "年" + (month + 1) + "月" + date + "日");23 System.out.println("--------------");24

25 c.set(2011, 11, 11);26 //获取年

27 year =c.get(Calendar.YEAR);28 //获取月

29 month =c.get(Calendar.MONTH);30 //获取日

31 date =c.get(Calendar.DATE);32 System.out.println(year + "年" + (month + 1) + "月" + date + "日");

* 获取任意一年的二月有多少天

1 //键盘录入任意的年份

2 Scanner sc = newScanner(System.in);3 System.out.println("请输入年份：");4 int year =sc.nextInt();5

6 //设置日历对象的年月日

7 Calendar c =Calendar.getInstance();8 c.set(year, 2, 1); //其实是这一年的3月1日9 //把时间往前推一天，就是2月的最后一天

10 c.add(Calendar.DATE, -1);11

12 //获取这一天输出即可

13 System.out.println(c.get(Calendar.DATE));

* 需求：判断一个数是否符合int类型的范围

* 由于基本数据类型只能做一些简单的操作和运算，所以Java为我们封装了基本数据类型，为每种基本数据类型提供了包装类

* 包装类就是封装了基本数据类型的类，为我们提供了更多复杂的方法和一些变量

1 //Integer(String s)

2 Integer i = new Integer("10");3System.out.println(i);4

5 //int intValue()

6 int a =i.intValue();7 System.out.println(a + 10);8

9 //static int parseInt(String s)

10 int b = Integer.parseInt("20");11 System.out.println(b + 30);12

13

14 //Integer(int value)

15 Integer i2 = new Integer(40);16 String s =i2.toString();17System.out.println(s);18

19 //static String toString(int i)

20 String s2 = Integer.toString(50);21 //System.out.println(s2);

* JDK1.5特性：自动装箱和拆箱

1 //自动装箱

2 //相当于： Integer i = new Integer(10);

3 //Integer i = 10;

4

5 //自动拆箱

6 //相当于 int a = i.intValue();

7 //Integer i = 10;

8 //int a = i;

9

10 Integer i = 10;11 Integer i2 = 20;12 Integer i3 = i +i2;13 /*14 * Integer i3 = new Integer(i.intValue() + i2.intValue());

15 *

16*/

17 ArrayList list = newArrayList();18 list.add(1);//自动装箱，list.add(new Integer(1));

正则表达式：就是一套规则，可以用于匹配字符串

boolean matches(String regex) ：判断当前字符串是否匹配指定的正则表达式，如果匹配则返回true，否则返回false

判断字符串是不是都由数字组成:

1 //必须都是数字

2 for (int i = 0; i < length; i++) {3 //得到参数的每一个字符

4 char c =qq.charAt(i);5 if(c < '0' || c > '9') {6 return false;7}8 }

或者:

1 char[] chs =qq.toCharArray();2 for (int x = 0; x < chs.length; x++) {3 char ch =chs[x];4 if (!Character.isDigit(ch)) {5 flag = false;6 break;7}8 }

* 校验qq号码

* 要求必须是5-15位

* 0不能开头

* 必须都是数字

boolean flag = qq.matches("[1-9][0-9]{4,14}");

//定义邮箱的规则

//String regex =

"[a-zA-Z_0-9]+@[a-zA-Z_0-9]{2,6}(\\.[a-zA-Z_0-9]{2,3})+";

String regex = "\\w+@\\w{2,6}(\\.\\w{2,3})+";

* 分割功能

* String类的public String[] split(String regex)

* 根据给定正则表达式的匹配拆分此字符串。

1 //定义一个年龄搜索范围

2 String ages = "18-24";3

4 //定义规则

5 String regex = "-";6

7 //调用方法

8 String[] strArray =ages.split(regex);9

10 // //遍历

11 //for(int x=0; x

12 //System.out.println(strArray[x]);

13 //}

14

15 //如何得到int类型的呢?

16 int startAge = Integer.parseInt(strArray[0]);17 int endAge = Integer.parseInt(strArray[1]);

//硬盘上的路径，我们应该用\\替代\

1 String s4 = "E:\\JavaSE\\day14\\avi";2 String[] str4Array = s4.split("\\\\");3 for (int x = 0; x < str4Array.length; x++) {4System.out.println(str4Array[x]);5 }

* 我有如下一个字符串:"91 27 46 38 50"

* 请写代码实现最终输出结果是："27 38 46 50 91"

1 //定义一个字符串

2 String s = "91 27 46 38 50";3

4 //把字符串进行分割，得到一个字符串数组

5 String[] strArray = s.split(" ");6

7 //把字符串数组变换成int数组

8 int[] arr = new int[strArray.length];9

10 for (int x = 0; x < arr.length; x++) {11 arr[x] =Integer.parseInt(strArray[x]);12}13

14 //对int数组排序

15Arrays.sort(arr);16

17 //把排序后的int数组在组装成一个字符串

18 StringBuilder sb = newStringBuilder();19 for (int x = 0; x < arr.length; x++) {20 sb.append(arr[x]).append(" ");21}22 //转化为字符串

23 String result =sb.toString().trim();24

25 //输出字符串

26 System.out.println("result:"+result);

* 替换功能

* String类的public String replaceAll(String

regex,String replacement)

* 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。

1 //定义一个字符串

2 String s = "helloqq12345worldkh622112345678java";3

4 //我要去除所有的数字,用*给替换掉

5 //String regex = "\\d+";

6 //String regex = "\\d";

7 //String ss = "*";

8

9 //直接把数字干掉

10 String regex = "\\d+";11 String ss = "";12

13 String result =s.replaceAll(regex, ss);14 System.out.println(result);

* 获取功能

* Pattern和Matcher类的使用

*

* 模式和匹配器的基本使用顺序

1 //模式和匹配器的典型调用顺序

2 //把正则表达式编译成模式对象

3 Pattern p = Pattern.compile("a*b");4 //通过模式对象得到匹配器对象，这个时候需要的是被匹配的字符串

5 Matcher m = p.matcher("aaaaab");6 //调用匹配器对象的功能

7 boolean b =m.matches();8 System.out.println(b);

* 获取功能：

* 获取下面这个字符串中由三个字符组成的单词

* da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?

1 //定义字符串

2 String s = "da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?";3 //规则

4 String regex = "\\b\\w{3}\\b";5

6 //把规则编译成模式对象

7 Pattern p =Pattern.compile(regex);8 //通过模式对象得到匹配器对象

9 Matcher m =p.matcher(s);10 //调用匹配器对象的功能

11 //通过find方法就是查找有没有满足条件的子串

12 //public boolean find()

13

14

15 while(m.find()) {16System.out.println(m.group());17}18

19 //注意：一定要先find()，然后才能group()

20 //IllegalStateException: No match found

21 //String ss = m.group();

22 //System.out.println(ss);

常用的正则表达式:

A:字符

x 字符 x。举例：'a'表示字符a

\\ 反斜线字符。

\n 新行(换行)符 ('\u000A')

\r 回车符 ('\u000D')

B:字符类

[abc] a、b 或 c(简单类)

[^abc] 任何字符，除了 a、b 或 c(否定)

[a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内(范围)

[0-9] 0到9的字符都包括

C:预定义字符类

. 任何字符。我的就是.字符本身，怎么表示呢? \.

\d 数字：[0-9]

\w 单词字符：[a-zA-Z_0-9]

在正则表达式里面组成单词的东西必须有这些东西组成

D:边界匹配器

^ 行的开头

$ 行的结尾

\b 单词边界

就是不是单词字符的地方。

举例：hello world?haha;xixi

E:Greedy 数量词

X? X，一次或一次也没有

X* X，零次或多次

X+ X，一次或多次

X{n} X，恰好 n 次

X{n,} X，至少 n 次

X{n,m} X，至少 n 次，但是不超过 m 次