黑马程序员——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);//sb:hlloworldjava,删除第二个字符 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呢？其实又对结果进行装箱。
注意事项：在装箱时，如果数值在byte范围之内，那么数值相同，不会产生新的对象，也就是说多个数值相同的引用指向的是同一个对象。Integer c= 127; Integer d =127; Integer e = 128; System.out.println(c== d); //true System.out.println(c==e);//false
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对象。
(1)方法Calendar rightNow = Calendar.getInstance(); //本质返回的是子类对象。
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) 根据日历的规则，为给定的日历字段添加或减去指定的时间量。
(2)静态常量若 amount为负数，则减去一天，
若 amount为正数 ，则加上一天
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));
}
}