黑马程序员----JAVA基础----常用对象API

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一、String类

1，字符串是一个特殊的对象，字符串一旦被初始化就不可以被改变。

当一个字符串被创建后，再使用时直接去字符串常量池中查找。

通过String类的构造函数创建的字符串，创建了两个对象。

public class StringDemo1 {

	public static void main(String[] args) {
		// “abc”存储在字符串常量池中
		String s1 = "abc";
		String s2 = "abc";
		// == 比较二者的地址值
		System.out.println(s1==s2);	// true
		// 下面语句创建了两个对象
		String s3 = new String("abc");
		System.out.println(s3==s1);	// false
		// equals 比较的是二者的内容
		System.out.println(s3.equals(s1));	// true
	}

}

由代码可以看出，s1和s2指向同一个对象，说明了字符串被创建后就不会改变。

2，String类一些常用的方法：其中indexOf、charAt等方法较为常用

public class StringDemo1 {

	public static void main(String[] args) {
		show1();
		showGet();		// 获取的方法展示
		showTrans();	// 转换
		showJudge();	// 判断
		showCompare();	// 比较
	}
	private static void showCompare() {
		/*
		 * 比较两个字符串的大小		int compareTo()
		 */
		System.out.println("java".compareTo("JAVA"));			//32
		System.out.println("java".compareToIgnoreCase("JAVA"));	// 0
	}

	private static void showJudge() {
		/*
		 * 判断：
		 * 1，判断两个字符串内容是否相同		boolean equals(Objectt o);
		 * 2，是否包含一个字符串			boolean contains(String str);
		 * 3，是否以某字符串开头或结尾		boolean startWith(String str);
		 * 							boolean endWith(Strng str);
		 */
		System.out.println("java".equals("java"));			// true
		// 忽略大小写比较内容
		System.out.println("java".equalsIgnoreCase("JAVA"));// true
		System.out.println("java".contains("ab"));			// false
		System.out.println("java".startsWith("a"));			// false
		System.out.println("java".endsWith("a"));			// true
	}

	private static void showTrans() {
		
		/*
		 * 转换：
		 * 1，将字符串转成字符串数组		String[] split(String regex);
		 * 2,将字符串转成字符数组		char[] toCharArray()
		 * 3,将字符串转成字节数组		byte[] getBytes;
		 * 4,字符串中的字符大小写转换	String toUpperCase()	String toLowerCase()
		 * 5，字符串中内容的替换		String replace(char oldch, char newch)
		 * 6，去除字符串两端的空格		String trim()
		 * 7,将基本数据类型变成字符串	String valueOf(int num)
		 */
		String str = "张三,李四,王五";
		String[] s = str.split(",");	// 张三 李四 王五
		char[] ch = str.toCharArray();	// 张 三 , 李 四 , 王 五 
		// -43 -59 -56 -3 44 -64 -18 -53 -60 44 -51 -11 -50 -27
		byte[] buf = str.getBytes();
		// 大小写转换
		System.out.println("java".toUpperCase());	// JAVA
		System.out.println("JAVA".toLowerCase());	// java
		// 字符替换
		System.out.println("java".replace('a', 'o'));	// jovo
		// 如果被替换的字符在字符串中没有，则返回原字符串
		System.out.println("java".replace('m', 'o'));	// java
		System.out.println("  - java   ".trim());		// - java
		System.out.println(String.valueOf(1)+1);		// 11
	}

	private static void showGet() {
		/*
		 * 获取：
		 * 1，获取字符串长度   		int length
		 * 2，根据位置获得字符		char charAt（int index）
		 * 3，根据字符获得位置		
		 * 		int indexOf（char ch） 从头开始第一次出现的位置
		 * 		int indexOf（char ch，int fromIndex）	从指定位置开始第一次出现
		 * 		int lastIndexOf（char ch）从尾部开始查找，第一次出现的位置
		 * 4,获取字符串中的部分	String subString(int beginIndex,int endIndex)
		 */
		String str = "abcddcba";
		int len = str.length(); // 8   
		char ch = str.charAt(2);// c
		int index1 = str.indexOf('c'); // 2
		int index2 = str.lastIndexOf('c');//5
		int index3 = str.indexOf('c',3);	// 5
		int index4 = str.indexOf("cd");	// 2
		String s = str.substring(2,5);	// cdd 包含头不包含尾
		System.out.println(s);
	}

	private static void show1() {
		// 等效于String str = “ ”；不等效String str = null；
		String str = new String(); 
		// 将字符数组或数组的一部分转化为字符串。
		char[] ch =  {'j','a','v','a','g','r'};
		String str1 = new String(ch);
		// 从1角标开始向后数3个
		String str2 = new String(ch,1,3);
		System.out.println(str1);	//javagr
		System.out.println(str2);	//ava
	}


}

3，String类练习1：

/**
 * 对给定的字符串数据进行排序
 * {"nba","abc","cba","zz","qq","haha"}
 * @author MATRIX
 * 思路：
 * 比较各个字符串的大小（comparTo）
 * 按顺序排列（选择排序）
 */
public class StringTest1 {

	public static void main(String[] args) {
		String[] str = {"nba","abc","cba","zz","qq","haha"};
		printStr(str);
		sortStr(str);
		printStr(str);
	}
	// 将打印的方法进行封装
	private static void printStr(String[] str) {
		System.out.print("[");
		for(int i=0; i<str.length; i++){
			System.out.print(str[i]+",");
			if(i==str.length-1)
				System.out.println("]");
		}
	}
	// 用选择排序
	private static void sortStr(String[] str) {
		for(int i=0; i<str.length-1; i++){
			for(int j=i+1; j<str.length; j++){
				// 用compareTo方法比较字符串的大小
				if(str[i].compareTo(str[j])>0){
					String temp = str[i];
					str[i] = str[j];
					str[j] = temp;
				}
					
			}
		}
	}

}

String类练习2：

/**
 * 一个子串在整串中出现的次数
 * "nbasdkfnbalksanbaksasafnba"
 * @author MATRIX
 * 思路：从头开开始在整串中查找子串   indexOf
 * 如果查到则记录一次，然后从子串出现的位置加上子串长度的位置开始查找
 * 只要结果部位-1就一直查找
 */
public class StringTest2 {

	public static void main(String[] args) {
		String str = "nbasdkfnbalksanbaksasafnba";
		String key = "nba";
		int count = findStr(key,str);
		System.out.println(count);
	}

	private static int findStr(String key,String str) {
		// 定义计数器
		int count = 0;
		int index = 0;
		// 使用indexOf查找子串的位置，不为-1说明存在，就+1
		while((index=str.indexOf(key,index))!=-1){
			count++;
			// 查询到子串位置后，应该跳过该子串，在剩余的字符串张查找
			index = index+key.length();
		}
		return count;
	}

}

4，StringBuffer类：字符串缓冲器区，用于存储数据的容器。

特点：长度是可变的，可以对字符串进行修改，可以存储不同类型的数据，但是最终要转成字符串使用。

一些常用方法：

public class StringBufferDemo {

	public static void main(String[] args) {
		/*
		 * 添加：	append、insert
		 * 删除：	delete、deleteCharAt
		 * 查找：	charAt、indexOf
		 * 修改：	setCharAt、replace
		 */
		// 创建缓冲区对象
		StringBuffer sb = new StringBuffer();
		// 可以添加各种类型的数据
		sb.append("abc");
		sb.append(4);
		sb.append(true);
		sb.insert(1, 'M');	// 从指定角标插入，原来该位置字符向后顺移
		System.out.println(sb.toString());	// aMbc4true
		// 删除
		sb.delete(0, 2);	// 删除时包含头，不包含尾              bc4true
		sb.deleteCharAt(sb.length()-1);	// 删除字符串末尾字符     bc4tru
//		sb.delete(0, sb.length());	// 清空字符串
		// 查找
		System.out.println(sb.charAt(1));//c
		System.out.println(sb.indexOf("true"));//-1
		// 修改
		System.out.println(sb.replace(0, 3, "java"));	// 包含头不包含尾    javatru
		sb.setCharAt(0, 'J');
		System.out.println(sb.toString());	// Javatru
	}

}

5，StringBuilder：jdk1.5后出现了功能和StirngBuffer一样的对象

二者的不同点：StringBuffer线程同步，通常用于多线程；

StringBuilder线程不同步，通常用于单线程，提高了效率。

jdk升级目标：简化书写，提高效率和增加安全性。

二、基本数据类型包装类对象

1，好处：将基本数据类型封装成对象，可以在对象中定义更多的功能和方法操作该数据

常见操作：基本数据类型与字符串之间的转换

2，八种基本数据类型：byte、short、int、long、float、double、char、boolean

对应包装类：Byte、Short、Integer、Long、Float、Double、Character、Boolean

3，基本数据类型转换为字符串：a，基本数据类型+“”；b，String类静态方法valueOf

（基本数据类型）c，Integer的静态方法valueOf（基本数据类型）。

字符串转换成基本数据类型：使用保证类的静态方法 xxx parseXxx（“xxx类型的字符串”）

比如 int parseInt（4）、long parseLong（44）、boolean  parseBoolean（“true”）等

注意Character没有该方法。

4，Integer类的一些常用方法：

public class WrapperDemo {

	public static void main(String[] args) {

		show1();	// 进制转换
		show2();	// 封装成对象后的一些方法
	}
	private static void show2() {
		Integer a = new Integer("3");
		Integer b = new Integer(3);
		Integer c = new Integer(40);
		System.out.println(a==b);			// false
		System.out.println(a.equals(b));	// true
		System.out.println(a.compareTo(c));	// -1
	}
	private static void show1() {
		Integer in = new Integer(8);
		// intValue将一个Integer对象转换成基本数据类型
		System.out.println(in.intValue());
		//  十进制--其他进制固定进制转换
		System.out.println(Integer.toBinaryString(60));
		System.out.println(Integer.toHexString(60));
		System.out.println(Integer.toOctalString(60));
		// 自定义进制转换
		System.out.println(Integer.toString(60, 3));
		// 其他进制---十进制
		System.out.println(Integer.parseInt("110",2));
		System.out.println(Integer.parseInt("3c",16));
	}

}

5，自动装箱与自动拆箱

public class IntegerDemo {

	public static void main(String[] args) {
		
		Integer i = 5;	// 自动装箱	将基本数据类型赋值给引用数据类型
		i = i+6;	// 自动拆箱	引用数据类型与基本数据类型运算
		
		// 如果自动装箱的是一个字节，那么该数据会被共享而不会开辟新的空间
		show(127);	// false true true true
		show(128);	// false true false true
		
		
	}

	/**
	 * 
	 */
	private static void show(int num) {
		Integer a = new Integer(num);	
		Integer b = new Integer(num);
		System.out.println(a==b);	// false
		System.out.println(a.equals(b));//true
		
		Integer x = num;
		Integer y = num;
		System.out.println(x==y);	// true
		System.out.println(x.equals(y));// true
	}

}

三、其他API对象

1，System类：

public class SystemDemo {

	public static void main(String[] args) {
		// 获得当前时间，毫秒
		long ll = System.currentTimeMillis();
		// 获取系统属性并存储到集合中
		Properties prop = System.getProperties();
		// 通过增强for来进行元素的读取
		Set<String> set = prop.stringPropertyNames();
		for(String name:set){
			String value = (String) prop.get(name);
			System.out.println(name+"---"+value);
		}
		// 换行,其中line。separator是关键字
		System.out.println("Hello"+System.getProperty("line.separator")+"World");
		// 设置系统信息
//		System.setProperty("myclasspath", "c:\\myclass");
		
	}

}

2，Runtime类：

public class RuntimeDemo {

	public static void main(String[] args) throws IOException {
		/*
		 * Runtime没有构造方法摘要，说明该类不可以创建对象
		 * 有非静态方法，说明该类由静态方法提供了获得对象的方法
		 * 说明Runtime类应用了单例设计模式
		 */
		// 由静态方法获取对象
		Runtime r = Runtime.getRuntime();
		// 用记事本打开ArrayListDemo。java
		r.exec("notepad D:\\JAVA\\Blog\\src\\ArrayListDemo.java");
		// 打开QQ程序
		r.exec("F:\\Program Files (x86)\\QQ\\Bin\\QQ.exe");
	}

}

3，Math类

public class MathDemo {

	public static void main(String[] args) {
		/*
		 * Math的方法都是静态的
		 */
		double d1 = Math.ceil(12.56);	// 返回大于参数的最小整数
		double d2 = Math.floor(12.56);	// 返回小于参数的最大整数
		double d3 = Math.round(12.56);	// 返回参数四舍五入的值
		System.out.println(d1+"--"+d2+"--"+d3);
		// 返回10的平方
		System.out.println(Math.pow(10, 2));
		// 获取随机值   返回1-10随机数
		for(int i=0; i<10; i++){
			int num1 = (int) Math.ceil(Math.random()*10);
			System.out.println(num1);
		}
		
		Random r = new Random();
		for(int i=0; i<10; i++){
			int d = r.nextInt(6);
			System.out.print(d+" ");
		}
	}

}

4，Date类

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

public class DateDemo {

	public static void main(String[] args) throws ParseException {
		
//		show();		// 系统格式
		show2();	// 自定义格式
		show3();	// 日期字符串-->日期对象
	}

	/**
	 * @throws ParseException
	 */
	private static void show3() throws ParseException {
		String str = "2013-8-18";
		DateFormat df = DateFormat.getDateInstance();
		Date date = df.parse(str);
		System.out.println(date);
	}

	/**
	 * 
	 */
	private static void show2() {
		Date date = new Date();
		DateFormat df = new SimpleDateFormat("yyyy--MM--dd");
		System.out.println(df.format(date));
	}

	private static void show() {
		Date date = new Date();
		System.out.println(date);
		// 毫秒值转成日期对象
		Date date1 = new Date(System.currentTimeMillis());
		System.out.println(date1);
		// 对日期对象进行格式化
		DateFormat df = DateFormat.getDateInstance();
		df = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
		System.out.println(df.format(date));
	}

}

日期练习：

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

public class DateTest {

	public static void main(String[] args) throws ParseException {
		String d1 = "2015-5-5";
		String d2 = "2015-8-8";
		// 定义日期格式
		DateFormat df = DateFormat.getDateInstance();
//		df = new SimpleDateFormat("yyyy-MM-dd");
		// 将日期字符串转换成日期对象
		Date date1 = df.parse(d1);
		Date date2 = df.parse(d2);
		//求两时间之差
		long time1 = date1.getTime();
		long time2 = date2.getTime();
		long time = Math.abs(time1-time2);
		System.out.println(time);
	}

}

5，Calendar类

import java.util.Calendar;

public class CalendarDemo {

	public static void main(String[] args) {
		// 创建对象
		Calendar c = Calendar.getInstance();
		// 得到年月日
		int year = c.get(Calendar.YEAR);
		int month = c.get(Calendar.MONTH);
		int day = c.get(Calendar.DAY_OF_MONTH);
		System.out.println(year+"-"+month+"-"+day);
	}

}

The End