一步一步学JAVA(15)-API

API：（Application Programming Interface,应用程序编程接口）是一些预先定义的函数，目的是提供应用程序与开发人员基于某软件或硬件的以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节。
String 字符串
java 中用String 类进行描述。对字符串进行了对象的封装。这样的好处是可以对字符串这种常见数据进行方便的操作。对象封装后，可以定义N 多属性和行为。
如何定义字符串对象呢？String s = "abc";只要是双引号引起的数据都是字符串对象。
特点：字符串一旦被初始化，就不可以被改变，存放在方法区中的常量池中。

String s1 = "abc"; // s1 指向的内存中只有一个对象abc。
String s2 = new String("abc"); // s2 指向的内容中有两个对象abc、new 。
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true ，字符串中equals 比较的是字符串内容是否相同。

字符串的方法：
1：构造方法：将字节数组或者字符数组转成字符串。

String s1 = new String();//创建了一个空内容的字符串。
String s2 = null;//s2 没有任何对象指向，是一个null 常量值。
String s3 = "";//s3 指向一个具体的字符串对象，只不过这个字符串中没有内容。
//一般在定义字符串时，不用new。
String s4 = new String("abc");
String s5 = "abc"; 一般用此写法
new String(char[]);//将字符数组转成字符串。
new String(char[],offset,count);//将字符数组中的一部分转成字符串。

2：一般方法：
按照面向对象的思想：
2.1 获取：
2.1.1：获取字符串的长度。length();
2.1.2：指定位置的字符。char charAt(int index);
2.1.3：获取指定字符的位置。如果不存在返回-1，所以可以通过返回值-1 来判断某一个字符不存在的情况。

int indexOf(int ch);//返回第一次找到的字符角标
int indexOf(int ch,int fromIndex); //返回从指定位置开始第一次找到的角标
int indexOf(String str); //返回第一次找到的字符串角标
int indexOf(String str,int fromIndex);
int lastIndexOf(int ch);
int lastIndexOf(int ch,int fromIndex);
int lastIndexOf(String str);
int lastIndexOf(String str,int fromIndex);

2.1.4：获取子串。

String substring(int start);//从start 位开始，到length()-1 为止.
String substring(int start,int end);//从start 开始到end 为止。//包含start 位，不包含end 位。
substring(0,str.length());//获取整串

2.2 判断：
2.2.1：字符串中包含指定的字符串吗？

boolean contains(String substring);

2.2.2：字符串是否以指定字符串开头啊？

boolean startsWith(string);

2.2.3：字符串是否以指定字符串结尾啊？

boolean endsWith(string);

2.2.4：判断字符串是否相同

boolean equals(string);//覆盖了Object 中的方法，判断字符串内容是否相同。

2.2.5：判断字符串内容是否相同，忽略大小写。

boolean equalsIgnoreCase(string) ;

2.3 转换：
2.3.1：通过构造函数可以将字符数组或者字节数组转成字符串。
2.3.2：可以通过字符串中的静态方法，将字符数组转成字符串。

static String copyValueOf(char[] );
static String copyValueOf(char[],int offset,int count);
static String valueOf(char[]);
static String valueOf(char[],int offset,int count);

2.3.3：将基本数据类型或者对象转成字符串。

static String valueOf(char);
static String valueOf(boolean);
static String valueOf(double);
static String valueOf(float);
static String valueOf(int);
static String valueOf(long);
static String valueOf(Object);

2.3.4：将字符串转成大小写。

String toLowerCase();
String toUpperCase();

2.3.5：将字符串转成数组。

char[] toCharArray();//转成字符数组。
byte[] getBytes();//可以加入编码表。转成字节数组。

2.3.6：将字符串转成字符串数组。切割方法。

String[] split(分割的规则-字符串);

2.3.7：将字符串进行内容替换。注意：修改后变成新字符串，并不是将原字符串直接修改。

String replace(oldChar,newChar);
String replace(oldstring,newstring);

2.3.8： String concat(string); //对字符串进行追加。

String trim();//去除字符串两端的空格
int compareTo();//如果参数字符串等于此字符串，则返回值 0；如果此字符串按字典顺序小于字符串参数，则返回一个小于 0 的值；如果此字符串按字典顺序大于字符串参数，则返回一个大于 0 的值。

StringBuffer 字符串缓冲区
构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。
特点：
1：可以对字符串内容进行修改。
2：是一个容器。
3：是可变长度的。
4：缓冲区中可以存储任意类型的数据。
5：最终需要变成字符串。
容器通常具备一些固定的方法：
1，添加。

StringBuffer append(data):在缓冲区中追加数据。追加到尾部。
StringBuffer insert(index,data):在指定位置插入数据。

2，删除。

StringBuffer delete(start,end);删除从start 至end-1 范围的元素
StringBuffer deleteCharAt(index);删除指定位置的元素
//sb.delete(0,sb.length());//清空缓冲区。

3，修改。

StringBuffer replace(start,end,string);将start 至end-1 替换成string
void setCharAt(index,char);替换指定位置的字符
void setLength(len);将原字符串置为指定长度的字符串

4，查找。（查不到返回-1）

int indexOf(string); 返回指定子字符串在此字符串中第一次出现处的索引。
int indexOf(string,int fromIndex);从指定位置开始查找字符串
int lastIndexOf(string); 返回指定子字符串在此字符串中最右边出现处的索引。
int lastIndexOf(string,int fromIndex); 从指定的索引开始反向搜索

5，获取子串。

string substring(start); 返回start 到结尾的子串
string substring(start,end); 返回start 至end-1 的子串

6，反转。

StringBuffer reverse();字符串反转

StringBuilder 字符串缓冲区
JDK1.5 出现StringBuiler；构造一个其中不带字符的字符串生成器，初始容量为 16 个字符。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。
方法和StringBuffer 一样；
StringBuffer 和 StringBuilder 的区别：
StringBuffer 线程安全。
StringBuilder 线程不安全。
单线程操作，使用StringBuilder 效率高。
多线程操作，使用StringBuffer 安全。

StringBuilder sb = new StringBuilder("abcdefg");
sb.append("ak"); //abcdefgak
sb.insert(1,"et");//aetbcdefg
sb.deleteCharAt(2);//abdefg
sb.delete(2,4);//abefg
sb.setLength(4);//abcd
sb.setCharAt(0,'k');//kbcdefg
sb.replace(0,2,"hhhh");//hhhhcdefg
//想要使用缓冲区，先要建立对象。
StringBuffer sb = new StringBuffer();
sb.append(12).append("haha");//方法调用链。
String s = "abc"+4+'q';
s = new StringBuffer().append("abc").append(4).append('q').toString();

 

class Test{
    public static void main(String[] args) {
        String s1 = "java";
        String s2 = "hello";
        method_1(s1,s2);
        System.out.println(s1+"...."+s2); //java....hello
        StringBuilder s11 = new StringBuilder("java");
        StringBuilder s22 = new StringBuilder("hello");
        method_2(s11,s22);
        System.out.println(s11+"-----"+s22); //javahello-----hello
    }
    public static void method_1(String s1,String s2){
        s1.replace('a','k');
        s1 = s2;
    }
    public static void method_2(StringBuilder s1,StringBuilder s2){
        s1.append(s2);
        s1 = s2;
    }
}

基本数据类型对象包装类：是按照面向对象思想将基本数据类型封装成了对象。
好处：
1：可以通过对象中的属性和行为操作基本数据。
2：可以实现基本数据类型和字符串之间的转换。
关键字      对应的类名
byte         Byte
short        Short paserShort(numstring);
int            Integer 静态方法：parseInt(numstring)
long         Long
float         Float
double     Double
char        Character
Boolean  Boolean
基本数据类型对象包装类：都有 XXX parseXXX 方法
只有一个类型没有parse 方法：Character ；
Integer 对象
数字格式的字符串转成基本数据类型的方法：
1：将该字符串封装成了Integer 对象，并调用对象的方法intValue();
2：使用Integer.parseInt(numstring):不用建立对象，直接类名调用；
将基本类型转成字符串：
1：Integer 中的静态方法 String toString(int);
2：int+"";
将一个十进制整数转成其他进制：
转成二进制：toBinaryString
转成八进制：toOctalString
转成十六进制：toHexString
toString(int num,int radix);
将其他进制转换十进制：
parseInt(string,radix); //将给定的数转成指定的基数进制；
在jdk1.5 版本后，对基本数据类型对象包装类进行升级。在升级中，使用基本数据类型对象包装类可以像使用基本数据类型一样，进行运算。
Integer i = new Integer(4); //1.5 版本之前的写法；
Integer i = 4; //自动装箱，1.5 版本后的写法；
i = i + 5;
//i 对象是不能直接和5 相加的，其实底层先将i 转成int 类型，在和5 相加。而转成int 类型的操作是隐
式的。自动拆箱：拆箱的原理就是i.intValue();i+5 运算完是一个int 整数。如何赋值给引用类型i 呢？其实
有对结果进行装箱。
Integer c = 127;
Integer d = 127;
System.out.println(c = = d); //true
//在装箱时，如果数值在byte 范围之内，那么数值相同，不会产生新的对象，也就是说多个数值相同的引用指向的是同一个对象。
API--- java.lang.System: 属性和行为都是静态的。

long currentTimeMillis(); // 返回当前时间毫秒值
exit(); // 退出虚拟机
Properties getProperties() ; // 获取当前系统的属性信息
Properties prop = System.getProperties(); //获取系统的属性信息，并将这些信息存储到Properties 集合中。
System.setProperty("myname","毕老师"); //给系统属性信息集添加具体的属性信息
//临时设置方式：运行jvm 时，可以通过jvm 的参数进行系统属性的临时设置，可以在java 命令的后面加入–D<name>=<value> 用法：java –Dmyname=小明 类名。
String name = System.getProperty("os.name");//获取指定属性的信息
//想要知道该系统是否是该软件所支持的系统中的一个。
Set<String> hs = new HashSet<String>();
hs.add("Windows XP");
hs.add("Windows 7");
if(hs.contains(name))
System.out.println("可以支持");
else
System.out.println("不支持");

API--- java.lang.Runtime: 类中没有构造方法，不能创建对象。
但是有非静态方法。说明该类中应该定义好了对象，并可以通过一个static 方法获取这个对象。用这个对象来调用非静态方法。这个方法就是 static Runtime getRuntime();
这个Runtime 其实使用单例设计模式进行设计。

class RuntimeDemo {
    public static void main(String[] args) throws Exception {
        Runtime r = Runtime.getRuntime();
        Process p = r.exec("notepad.exe SystemDemo.java"); //运行指定的程序
        Thread.sleep(4000);
        p.destroy(); //杀掉进程
    }
}

---

API--- java.util.Math: 用于数学运算的工具类，属性和行为都是静态的。该类是final 不允许继承。

static double ceil(double a) ; //返回大于指定数值的最小整数
static double floor(double a) ; //返回小于指定数值的最大整数
static long round(double a) ; //四舍五入成整数
static double pow(double a, double b) ; //a 的b 次幂
static double random(); //返回0~1 的伪随机数
public static void main(String[] args) {
    Random r = new Random();
    for(int x=0; x<10; x++) {
        //double d = Math.floor(Math.random()*10+1);
        //int d = (int)(Math.random()*10+1);
        int d = r.nextInt(10)+1;
        System.out.println(d);
    }
}

API--- java.util.Date：日期类，月份从0-11；

/*
日期对象和毫秒值之间的转换。
1，日期对象转成毫秒值。Date 类中的getTime 方法。
2，如何将获取到的毫秒值转成具体的日期呢？
Date 类中的setTime 方法。也可以通过构造函数。
*/
//日期对象转成毫秒值
Date d = new Date();
long time1 = d.getTime();
long time2 = System.currentTimeMillis(); / /毫秒值。
//毫秒值转成具体的日期
long time = 1322709921312l;
Date d = new Date();
d.setTime(time);
/*
将日期字符串转换成日期对象：使用的就是DateFormat 方法中的 Date parse(String source) ；
*/
public static void method() throws Exception {
    String str_time = "2011/10/25";
    DateFormat df = new SimpleDateFormat("yyyy/MM/dd"); //SimpleDateFormat 作为可以指定用户自定义的格式来完成格式化。
    Date d = df.parse(str_time);
}
/*
如果不需要使用特定的格式化风格，完全可以使用DateFormat 类中的静态工厂方法获取具体的已经封装好风格的对象。getDateInstance();getDateTimeInstance();
*/
Date d = new Date();
DateFormat df = DateFormat.getDateInstance(DateFormat.LONG);
df = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
String str_time = df.format(d);
//将日期对象转换成字符串的方式：DateFormat 类中的format 方法。
//创建日期格式对象。
DateFormat df = new SimpleDateFormat(); //该对象的建立内部会封装一个默认的日期格式。11-12-1 下午1:48
//如果想要自定义日期格式的话。可使用SimpleDateFormat 的构造函数。将具体的格式作为参数传入
到构造函数中。如何表示日期中年的部分呢？可以必须要参与格式对象文档。
df = new SimpleDateFormat("yyyy 年MM 月dd 日 HH:mm:ss");
//调用DateFormat 中的format 方法。对已有的日期对象进行格式化。
String str_time = df.format(d);

--------------------------------------------------------------------------------------------------------------------
API--- java.util. Calendar：日历类

public static void method(){
    Calendar c = Calendar.getInstance();
    System.out.println(c.get(Calendar.YEAR)+"年"+(c.get(Calendar.MONTH)+1)+"月"
    +getNum(c.get(Calendar.DAY_OF_MONTH))+"日"
    +"星期"+getWeek(c.get(Calendar.DAY_OF_WEEK)));
}
public static String getNum(int num){
    return num>9 ? num+"" : "0"+num;
}
public static String getWeek(int index){
    /*
        查表法：建立数据的对应关系.
        最好：数据个数是确定的，而且有对应关系。如果对应关系的一方，是数字，而且可以作为角标，那么可以通过数组来作为表。
    */
    String[] weeks = {"","日","一","二","三","四","五","六"};
    return weeks[index];
}

• 一步一步学JAVA(1)-初识java
• 一步一步学JAVA(2)-JDK的配置
• 一步一步学JAVA(3)-javac与java 命令
• 一步一步学JAVA(4)-语法基础
• 一步一步学JAVA(5)-面向对象
• 一步一步学JAVA(6)-封装
• 一步一步学JAVA(7)-继承
• 一步一步学JAVA(8)-多态
• 一步一步学JAVA(9)-设计模式
• 一步一步学JAVA(10)-接口
• 一步一步学JAVA(11)-异常
• 一步一步学JAVA(12)-多线程
• 一步一步学JAVA(13)-同步
• 一步一步学JAVA(14)-集合框架
• 一步一步学JAVA(15)-API
• 一步一步学JAVA(16)-IO流
• 一步一步学JAVA(17)-网络编程
• 一步一步学JAVA(18)-反射技术
• 一步一步学JAVA(19)-正则表达式