黑马程序员——Java常用对象

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

1：Scanner

(1)在JDK5以后出现的用于键盘录入数据的类。

(2)构造方法：

A:其实是标准的输入流,对应于键盘录入

B:构造方法

InputStream is = System.in;

Scanner(InputStream is)

C:常用的格式

Scanner sc = new Scanner(System.in);

(3)基本方法：

A:hasNextXxx() 判断下一个标记是否是某种类型的

B:nextXxx() 将下一个标记返回为某种类型的元素

(4)要掌握的方法

A:public int nextInt() 

B:public String nextLine()  返回当前一行

C:public boolean hasNext()判断后面是否还有数据

(5)注意事项

A:同一个Scanner对象，先获取数值，再获取字符串会出现一个小问题。

B:解决方案：

a:重新定义一个Scanner对象

b:把所有的数据都用字符串获取，然后再进行相应的转换

2：String字符串

多个字符组成的一串数据。其实它可以和字符数组进行相互转换。

(1)构造方法：

A:public String():空构造

B:public String(byte[] bytes):把字节数组转成字符串

C:public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串

D:public String(char[] value):把字符数组转成字符串

E:public String(char[] value,int index,int count):把字符数组的一部分转成字符串

F:  public String(String original):把字符串常量值转成字符串

下面的这一个虽然不是构造方法，但是结果也是一个字符串对象

G:String s = "hello";定义字符串一般使用这种方法。

(2)字符串的特点

A:字符串一旦被赋值，就不能改变。

注意：这里指的是字符串的内容不能改变，而不是引用不能改变。

public class StringDemo{
    public static void main(String[] args){
  	String s = "abc";
	s = "def";
	System.out.println("s = " + s);// s = def."abc"字符串对象并没有被改变,只是引用变量s指向了新创建的字符串对象"nba"。
    }
}

B:字面值作为字符串对象和通过构造方法创建对象的不同

public class StringDemo{
    public static void main(String[] args){
    	String s1 = "abc";
 	String s2 = "abc";
	String s3 = new String("abc");
	System.out.println(s1 == s2);//true;s1,s2指向同一个字符串
	System.out.println(s1 == s3);//false;s3在堆内存中创建了另外一个"abc"字符串对象。
    }
}

(3)字符串的面试题

A:==和equals()

public class StringDemo{
    public static void main(String[] args){
	String s1 = new String("hello");
	String s2 = new String("hello");
	System.out.println(s1 == s2);// false,两个对象的地址值不同。
	System.out.println(s1.equals(s2));// true，比较的是内容。
	String s3 = "hello";
	System.out.println(s1 == s3);// false//两个对象
	System.out.println(s1.equals(s3));// true内容相同
	String s4 = "hello";
	System.out.println(s5 == s6);// true//同一个对象
	System.out.println(s5.equals(s6));// true
      }
}

B:字符串的拼接

字符串如果是变量相加，先开空间，在拼接。

字符串如果是常量相加，是先加，然后在常量池找，如果有就直接返回，否则，就创建。

public class StringDemo{
    public static void main(String[] args){
	String s1 = "hello";
	String s2 = "world";
	String s3 = "helloworld";
	System.out.println(s3 == s1 + s2);// false 新字符串与s3的地址值不同。
	System.out.println(s3.equals((s1 + s2)));// true，新字符串与s3内容相同。
	System.out.println(s3 == "hello" + "world");//true，常量先加。
	System.out.println(s3.equals("hello" + "world"));// true
      }
}

(4)字符串的功能

A:判断功能

boolean equals(Object obj):比较字符串的内容是否相同,区分大小写

boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写

boolean contains(String str):判断大字符串中是否包含小字符串

boolean startsWith(String str):判断字符串是否以某个指定的字符串开头

boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾

boolean isEmpty():判断字符串是否为空。

注意事项：

字符串内容为空和字符串对象为空不一样。

String s = "";

      String s = null;

B:获取功能

int length():获取字符串的长度。

char charAt(int index):获取指定索引位置的字符

int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。

为什么这里是int类型，而不是char类型?

原因是：'a'和97其实都可以代表'a'

int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。

int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。

int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。

String substring(int start):从指定位置开始截取字符串,默认到末尾。

String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。

C:转换功能

byte[] getBytes():把字符串转换为字节数组。

char[] toCharArray():把字符串转换为字符数组。

static String valueOf(char[] chs):把字符数组转成字符串。

static String valueOf(int i):把int类型的数据转成字符串。

注意：String类的valueOf方法可以把任意类型的数据转成字符串。

String toLowerCase():把字符串转成小写。

String toUpperCase():把字符串转成大写。

D:其他功能

替换功能：修改后变成新字符串，并不是将原字符串直接修改。

String replace(char old,char new)

String replace(String old,String new)

去除字符串两空格

String trim()

按字典顺序比较两个字符串  

int compareTo(String str)

int compareToIgnoreCase(String str)

追加字符串

String concat(string)

3：StringBuffer

就是字符串缓冲区，用于存储数据的容器，初始容量为 16 个字符。

(1)特点

A:可以对字符串内容进行修改。

B:是一个容器。

C:是可变长度的。

D:缓冲区中可以存储任意类型的数据。

F:最终需要变成字符串。

(2)StringBuffer的构造方法

A:public StringBuffer():无参构造方法

B:public StringBuffer(int size):指定容量的字符串缓冲区对象

C:public StringBuffer(String str):指定字符串内容的字符串缓冲区对象

(3)StringBuffer的常见功能

A:添加功能

a: public StringBuffer append(String str):

可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身。

b: public StringBuffer insert(int offset,String str):

在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身。

public class StringBufferDemo{
      public static void main(String[] args){
            StringBuffer sb = new StringBuffer();
            sb.append("hello").append(true).append(12).append(34.56);//链式编程，添加任意数据
	        System.out.println("sb:" + sb);
            sb.insert(5, "world");//指定位置插入任意类型数据。
	        System.out.println("sb:" + sb);
      }
}

B:删除功能

a: public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身

b: public StringBuffer delete(int start,int end):删除从从start至end-1范围的元素，并返回本身

public class StringBufferDemo {
	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer();
		sb.append("hello").append("world").append("java");//添加数据
		System.out.println("sb:" + sb);
                sb.deleteCharAt(1);
                System.out.println("sb:" + sb);<span style="font-family: Arial, Helvetica, sans-serif;">//sb:hlloworldjava,删除第二个字符</span>
                sb.delete(5, 10);
                System.out.println("sb:" + sb);//sb:hllowava,删除第6到第10个字符，包前不包后
                sb.delete(0, sb.length());
		System.out.println("sb:" + sb);//sb:,清空
       }
}

C:替换功能

a: public StringBuffer replace(int start,int end,String str):从start开始到end-1用str替换

b: void setCharAt(index,char);替换指定位置的字符

c: void setLength(len);将原字符串置为指定长度的字符串

D:反转功能

StringBuffer reverse()

//判断输入的字符串是否对称
public class StringBufferTest {
	public static void main(String[] args) {
		// 创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串：");//输入 asdsa
		String s = sc.nextLine();

		//用字符串缓冲区的反转功能
		boolean flag = isSame(s);
		System.out.println("flag:"+flag);//flag：true
	}
	
	public static boolean isSame(String s) {
		return new StringBuffer(s).reverse().toString().equals(s);
	}
}

E:截取功能

a: public String substring(int start)：返回start到结尾的子串

b: public String substring(int start,int end)：返回start至end-1的子串

F:查找(查不到返回-1)

a: int indexOf(string); 返回指定子字符串在此字符串中第一次出现处的索引。

b: int indexOf(string,intfromIndex);从指定位置开始查找字符串

c: int lastIndexOf(string); 返回指定子字符串在此字符串中最右边出现处的索引。

d: int lastIndexOf(string,int fromIndex); 从指定的索引开始反向搜索

(4)StringBuilder

JDK1.5以后出现的功能和StringBuffer一模一样的对象。构造一个其中不带字符的字符串生成器，初始容量为 16 个字符。

单线程操作，使用StringBuilder 效率高。

多线程操作，使用StringBuffer 安全。

(5)注意事项

A：String,StringBuffer,StringBuilder的区别?

A:String是内容不可变的，而StringBuffer,StringBuilder都是内容可变的。

B:StringBuffer是同步的，数据安全,效率低。

C:StringBuilder是不同步的,数据不安全,效率高。

B：StringBuffer和数组的区别?

二者都可以看出是一个容器，装其他的数据。但是呢,StringBuffer的数据最终是一个字符串数据。

而数组可以放置多种数据，但必须是同一种数据类型的。 

C:形式参数问题

String作为参数传递，效果和基本类型作为参数传递是一样的

StringBuffer作为参数传递 

基本类型：形式参数的改变不影响实际参数

引用类型：形式参数的改变直接影响实际参数

4：Arrays工具类

Arrays:针对数组进行操作的工具类。比如说排序和查找。

A:public static String toString(int[] a) 把数组转成字符串

B:public static void sort(int[] a) 对数组进行排序

C:public static int binarySearch(int[] a,int key) 二分查找

public class ArraysDemo {
	public static void main(String[] args) {
		// 定义一个数组
		int[] arr = { 24, 69, 80, 57, 13 };

		// public static String toString(int[] a) 把数组转成字符串
		System.out.println("排序前：" + Arrays.toString(arr));//排序前：[24, 69, 80, 57, 13]

		// public static void sort(int[] a) 对数组进行排序
		Arrays.sort(arr);
		System.out.println("排序后：" + Arrays.toString(arr));//排序后：[13, 24, 57, 69, 80]

		// public static int binarySearch(int[] a,int key) 二分查找
		System.out.println("binarySearch:" + Arrays.binarySearch(arr, 57));//binarySearch:2
		System.out.println("binarySearch:" + Arrays.binarySearch(arr, 577));//binarySearch:-6 超出数组范围，返回-(数组长度+1)
	}
}

5：基本数据类型对象包装类

为了让基本类型的数据进行更多的操作，Java就为每种基本类型提供了对应的包装类类型，是按照面向对象思想将基本数据类型封装成了对象。

基本数据类型	对应的类名
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

基本数据类型对象包装类：都有 XXX parseXXX 方法

只有一个类型没有parse方法：Character ；

(1)好处：

A:可以通过对象中的属性和行为操作基本数据。

B:可以实现基本数据类型和字符串之间的转换。

(2)Integer

A:构造方法：

a: public Integer(int value)

b: public Integer(String s)

注意：这个字符串必须是由数字字符组成

B:String和int的相互转换

a:String --> int

Integer.parseInt("100");

如果字符串被Integer进行对象的封装,可使用另一个非静态的方法,intValue，

将一个Integer对象转成基本数据类型值。

用Integer的静态方法valueOf(String s)；

b:int --> String

String.valueOf(100);

基本数据类型+" ";

C:JDK5的新特性

自动装箱  基本类型--引用类型Integer i = 4; //自动装箱

自动拆箱引用类型--基本类型 i = i + 5;// i对象是不能直接和5相加的，其实底层先将i转成int类型，在和5相加。而转成int类型的操作是隐式的。自动拆箱：拆箱的原理就是i.intValue();i+5运算完是一个int整数。如何赋值给引用类型i呢？其实又对结果进行装箱。

Integer c= 127;
Integer d =127;
Integer e = 128;
System.out.println(c== d); //true
System.out.println(c==e);//false

注意事项：在装箱时，如果数值在byte范围之内，那么数值相同，不会产生新的对象，也就是说多个数值相同的引用指向的是同一个对象。

6：正则表达式

就是符合一定规则的字符串

(1)常见规则

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 次 

(2)常见功能：

A:判断功能

String类的public boolean matches(String regex)

B:分割功能

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

C:替换功能

String类的public String replaceAll(String regex,String replacement)

D:获取功能

Pattern和Matcher

Pattern p = Pattern.compile("a*b");

Matcher m = p.matcher("aaaaab");

find():查找存不存在

group():获取刚才查找过的数据A

7：Math

针对数学运算进行操作的类。

(1)成员变量：

public static final double PI

public static final double E

(2)成员方法：

public static int abs(int a)：绝对值
public static double ceil(double a):向上取整  
public static double floor(double a):向下取整

public static int max(int a,int b):最大值 

public static int min(int a, int b):最小值

public static double pow(double a,double b):a的b次幂
public static double random():随机数 [0.0,1.0)，返回带正号的 double 值
public static int round(float a) 四舍五入
public static double sqrt(double a):正平方根

8：Random

产生随机数的类

(1)构造方法：

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

public Random(long seed):给出指定的种子。给定种子后，每次得到的随机数是相同的。

(2)成员方法：

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

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

9：System

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

方法：

public static void gc()：运行垃圾回收器。 

public static void exit(int status):

终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。 

public static long currentTimeMillis():返回以毫秒为单位的当前时间

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

从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。

10：Date/DateFormat
(1)Date是日期类，可以精确到毫秒。

A:构造方法

Date():根据当前的默认毫秒值创建日期对象

Date(long time):根据给定的毫秒值创建日期对象

B:成员方法

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

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

C:日期和毫秒值的相互转换

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

/*
 * 算一下你来到这个世界多少天?
 * 
 * 分析：
 * 		A:键盘录入你的出生的年月日
 * 		B:把该字符串转换为一个日期
 * 		C:通过该日期得到一个毫秒值
 * 		D:获取当前时间的毫秒值
 * 		E:用D-C得到一个毫秒值
 * 		F:把E的毫秒值转换为年
 * 		     /1000/60/60/24
 */
public class MyYearOldDemo {
	public static void main(String[] args) throws ParseException {
		// 键盘录入你的出生的年月日
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入你的出生年月日:");
		String line = sc.nextLine();

		// 把该字符串转换为一个日期
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Date d = sdf.parse(line);

		// 通过该日期得到一个毫秒值
		long myTime = d.getTime();

		// 获取当前时间的毫秒值
		long nowTime = System.currentTimeMillis();

		// 用D-C得到一个毫秒值
		long time = nowTime - myTime;

		// 把E的毫秒值转换为年
		long day = time / 1000 / 60 / 60 / 24;

		System.out.println("你来到这个世界：" + day + "天");
	}
}

(2)DateFormat针对日期进行格式化和针对字符串进行解析的类，但是是抽象类，所以使用其子类SimpleDateFormat

A:SimpleDateFormat(String pattern) 给定模式

yyyy-MM-dd HH:mm:ss

   年   月  日  时    分  秒

B:日期和字符串的转换

a:Date -- String(格式化)

public final String format(Date date) 按某种时间格式输出指定的String类型时间

b:String -- Date(解析)

public Date parse(String source)把某种时间格式的String时间转成Date类型时间

C:一个针对日期操作的工具类。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateUtil {
	private DateUtil() {
	}
	/**
	 * 这个方法的作用就是把日期转成一个字符串
	 * 
	 * @param d
	 *            被转换的日期对象
	 * @param format
	 *            传递过来的要被转换的格式
	 * @return 格式化后的字符串
	 */
	public static String dateToString(Date d, String format) {
		return new SimpleDateFormat(format).format(d);
	}

	/**
	 * 这个方法的作用就是把一个字符串解析成一个日期对象
	 * 
	 * @param s
	 *            被解析的字符串
	 * @param format
	 *            传递过来的要被转换的格式
	 * @return 解析后的日期对象
	 * @throws ParseException
	 */
	public static Date stringToDate(String s, String format)
			throws ParseException {
		return new SimpleDateFormat(format).parse(s);
	}
}

11：Calendar

日历类，封装了所有的日历字段值，通过统一的方法根据传入不同的日历字段可以获取值。

是抽象类，不能实例化，通过static Calendar getInstance() 获得一个Calendar对象。

Calendar rightNow = Calendar.getInstance();  //本质返回的是子类对象。

(1)方法

int get(int field):返回指定日历字段值

Date getTime() 返回一个表示此 Calendar 时间值的 Date 对象。

void set(int year, int month, int date, inthour, int minute, int second)   设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的值。

abstract void add(int field, int amount) 根据日历的规则，为给定的日历字段添加或减去指定的时间量。

若 amount为负数，则减去一天，

若 amount为正数 ，则加上一天

(2)静态常量

YEAR 表示年的字段数字。

MONTH 表示月份字段数字,月份范围是[0,11]。

DATE 表示一个月中的某天。

DAY_OF_MONTH 表示一个月中的某天。

DAY_OF_WEEK 表示一个星期中的某天。

HOUR_OF_DAY / HOUR 表示第几小时

MINUTE 表示第几分钟

SECOND       表示第几秒

(3)获取任意一年的二月有多少天

import java.util.Calendar;
import java.util.Scanner;
public class CalendarTest {
	public static void main(String[] args) {
		// 键盘录入任意的年份
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入年份：");
		int year = sc.nextInt();

		// 设置日历对象的年月日
		Calendar c = Calendar.getInstance();
		c.set(year, 2, 1); // 其实是这一年的3月1日
		// 把时间往前推一天，就是2月的最后一天
		c.add(Calendar.DATE, -1);

		// 获取这一天输出即可
		System.out.println(c.get(Calendar.DATE));
	}
}