黑马程序员——API常见对象

最新推荐文章于 2022-10-24 10:32:00 发布

ttuzanhua

最新推荐文章于 2022-10-24 10:32:00 发布

阅读量275

点赞数

本文链接：https://blog.csdn.net/ttuzanhua/article/details/45463125

版权

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

第一部分:API概述

API(应用程序编程接口)概述:

API(Application Programming Interface)即应用程序编程接口。

例如：编写一个机器人程序去控制机器人踢足球，程序就需要向机器人发出向前跑、向后跑、射门、抢球等各种命令，没有编过程序的人很难想象这样的程序如何编写。但是对于有经验的开发人员来说，知道机器人厂商一定会提供一些用于控制机器人的Java类，这些类中定义好了操作机器人各种动作的方法。其实，这些Java类就是机器人厂商提供给应用程序编程的接口，大家把这些类称为Xxx Robot API。

第二部分:API中开发时常用的类。

API中常见的类：

Object 类：它是类层次结构的根类；所有类都直接或者间接的继承自该类。

Object 构造方法：

Object(){} 空参数构造方法。子类的构造方法默认访问的是父类的无参构造方法。

Object 普通方法：

protected Object clone() 创建并返回此对象的一个副本。

protected void finalize() 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。对象的垃圾回收器： public static void gc()运行垃圾回收器。调用 gc 方法暗示着 Java 虚拟机做了一些努力来回收未用对象，以便能够快速地重用这些对象当前占用的内存。

public int HashCode() 返回该对象的哈希码值

哈希码值我们可以理解为就是对象的地址值。但是在java中我们是不能够获取到内村的地址值的，所以说这个hashCode得到的地址值不是内存中真正的地址，这个地址值其实叫哈希码值。

同一个对象的哈希码值是相同的。

不同对象的哈希码值一般情况下是不同的。

public final Class getClass()返回此 Object 的运行时类（通过那个.class文件创建的该对象）。

String （字符串）类：

概述：字符串是由多个字符组成的一串数据(字符序列)，字符串可以看成是字符数组。

构造方法：

public String()：空参数构造方法。

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

public String(byte[] bytes, int startIndex, int length) 把字节数组一部分转换成字符串

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

public String(char[] value, int startIndex, int count)把字符数组一部分转换成字符串。

public String(String original) 把字符串转换成字符串对象。

String的几道常见题目：

字符串是常量；它们的值在创建之后不能更改（地址值可以更改）; 因为 String 对象是不可变的，所以可以共享。

第一题：

String s = new String(“hello”)和String s = “hello”;的区别是什么？

String s = new String(“hello”) 创建了两个对象，一个是new String()对象，另一个是"hello"对象。

String s = "hello"; 创建了一个对象， "hello"对象。

第二题：

String s1 = "hello";

String s2 = "world";

String s3 = "helloworld";

System.out.println(s3 == s1+s2 ); // false 解释地址值发生改变

System.out.println(s3 == "hello" + "world");//true 解释：S3直接在字符串常量池中拿到"hello"和"world"组成的helloword 所以地址值是相同的。

System.out.println(s3.equals(s1+s2)); //true

String 中常用的普通方法：

获取功能的方法：

int length() ：获取当前字符串的长度

char charAt(int index): 获取当前字符串中，给定索引位置对应的字符

int indexOf(int ch) : 获取当前字符串中，给定的字符第一次出现的位置，没有找到返回-1

int indexOf(String str): 获取当前字符串中，给定的字符串第一次出现的位置，没有找到返回-1

int indexOf(int ch,int fromIndex)从指定的位置开始，获取当前字符串中，给定的字符第一次出现的位置，没有找到返回-1

int indexOf(String str,int fromIndex)从指定的位置开始,获取当前字符串中，给定的字符串第一次出现的位置，没有找到返回-1

String substring(int start) 从指定的位置开始，截取当前字符串到末尾，返回一个新的字符串

String substring(int start,int end)从指定位置开始，到指定位置结束，截取当前字符串，返回一个新的字符串

注意：substring(int start,int end) 包含起始位置字符，不包含结束位置字符

用两道习题来解释上面的功能

第一题：

public class StringMethodTest {

public static void main(String[] args) {

// 定义一个字符串

String str = "HelloWorld";

//调用printString（）方法打印出结果

String result = printString(str);

System.out.println(result);

}

//遍历字符串方法 [H,e,l,...]

public static String printString(String str){

String result = "[";

// for循环，循环条件？？？获取到字符串的长度 length()

for (int i = 0; i < str.length(); i++) {

//3: 每次获取指定位置的字符

char ch = str.charAt(i);

if (i == str.length() -1) {

//判断是否为最后一个元素

result = result + ch + "]";

} else {

result = result + ch + ", ";

}

return result;

}

第二题：

import java.util.Scanner;

public class StringMethodTest2 {

public static void main(String[] args) {

//键盘输入字符串

Scanner sc = new Scanner(System.in);

System.out.println("请输入字符串：");

String str = sc.nextLine();

//定义变量，大写个数，小写个数，数字个数

int BigCount = 0;

int SmallCount = 0;

int NumberCount = 0;

//遍历字符串

for (int i = 0; i < str.length(); i++) {

//获取每一个字符 ch

char ch = str.charAt(i);

//判断当前字符的类型

if ( ch>='A' && ch <= 'Z') {

//大写个数++

BigCount++;

} else if (ch>='a' && ch <='z') {

//小写个数++

SmallCount++;

} else if ( ch>='0' && ch <='9') {

//数字个数++

NumberCount++;

}

//打印

System.out.println("大写字符： " + BigCount );

System.out.println("小写字符： " + SmallCount );

System.out.println("数字字符： " + NumberCount );

}

String类的转换功能：

byte[] getBytes() 把当前字符串转换成字节数组

char[] toCharArray() 把当前字符串转换成字符数组

static String valueOf(char[] chs) 静态方法，把给定的字符数组转换成字符串

static String valueOf(int i) 静态方法，把基本数据类型转换成字符串

String toLowerCase() 把当前字符串全部转换为小写字母

String toUpperCase() 把当前字符串全部转换为大写字母

String concat(String str) 把当前字符串与给定的字符串进行拼接

用一个案例来解释

public class StringMethodTest {

public static void main(String[] args) {

//1: 定义一个字符串

String str = "aaaaAbCdEfG";

//2: 获取首字母，然后大写

String start = str.substring(0, 1);

String big = start.toUpperCase();

//3: 获取其他字母，然后小写

String end = str.substring(1);

String small = end.toLowerCase();

//4: 拼接

String result = big + small;

System.out.println(result);//结果为Aaaaabcdefg

}

替换功能

String replace(char old,char new) 把当前字符串中，给定的旧字符，用新字符替换

String replace(String old,String new) 把当前字符串中，给定的旧字符串，用新字符串替换

public class StringMethodDemo {

public static void main(String[] args) {

String str = "HelloJava";

//String replace(char old,char new) 把当前字符串中，给定的旧字符，用新字符替换

String result = str.replace('a', 'E');

System.out.println("str:" + str);//结果为:HelloJava

System.out.println("result:" + result);//结果为HElloJava

//String replace(String old,String new) 把当前字符串中，给定的旧字符串，用新字符串替换

String result2 = str.replace("Java", "你好");

System.out.println("str:" + str);//结果为:java

System.out.println("result2:" + result2);//结果为:你好

}

Scanner类概述：把键盘录入操作进行了封装，通过该类可以获取到任意类型的数据，在jdk1.5开始。

构造方法：

public Scanner(InputStream source)

方法：

public int nextXxx(Xxx radix):

获取Xxx类型的键盘录入的数据, Xxx代表各种基本数据类型

public boolean hasNextXxx():

判断键盘输入的数据是否为Xxx类型的数据

使用方法：

StringBuffer：字符串缓冲区

String和StringBuffer的区别：

String：长度固定，内容固定。

SringBuffer：长度不固定，内容可变。

StrigBuffer 和StringBuilder 区别

StringBuffer 多线程安全,效率低。

StringBuilder 单线程不安全,效率高。

StringBuffer构造方法：

public StringBuffer() 构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。

public StringBuffer(int capacity) 构造一个不带字符，但具有指定初始容量的字符串缓冲区。

public StringBuffer(String str)构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16 加上字符串参数的长度。

普通方法：

public int capacity()返回当前容量（框的容量）

public int length() 返回长度（字符数）。 (框中实际使用的容量)

添加功能的方法：

public StringBuffer append(String str) : 追加，在原有数据的基础上，添加新数据

将指定的参数类型数据[任意类型数据]，添加到当前的字符串缓冲区对象中，返回当前字符串缓冲区对象

public StringBuffer insert(int offset,String str)

在指定的位置上，将指定的参数类型数据[任意类型数据]，插入到当前的字符串缓冲区对象中，返回当前字符串缓冲区对象

删除功能的方法：

public StringBuffer deleteCharAt(int index)

把指定位置上的字符，在当前的字符串缓冲区对象中删除，返回当前字符串缓冲对象。

public StringBuffer delete(int start,int end)

从指定位置开始，到指定位置结束，在当前的字符串缓冲区对象中删除，返回当前字符串缓冲对象（包左不包右）。

替换功能的方法：

public StringBuffer replace(int start,int end,String str) 包左不包右

从指定位置开始，到指定位置结束，用给定的字符串，将字符串缓冲区中的数据替换,返回当前的字符串缓冲区对象。

反转功能方法：

public StringBuffer reverse()//反转，返回当前的字符串缓冲区对象。

StringBuffer截取功能的方法：

注意：截取的方法与其他的方法不同它返回的是字符串类型字符串缓冲区内长度不变

public String substring(int start)

从指定位置开始到最后，截取该字符串缓冲区的数据，返回字符串对象。

public String substring(int start,int end)

从指定位置开始到指定位置结束，截取该字符串缓冲区的数据，返回字符串对象。

下面以练习题来说明上面的方法：

题目：把数组拼接成一个字符串并输出打印

数组：int[] arr = {1,2,3,4,5};

字符串：String str 内容： [1, 2, 3, 4, 5]

分析的过程很重要：

分析：a):创建一个数组 int[] arr = {1,2,3,4,5};

b)创建一个字符串缓冲区对象来接受并存放遍历数组后的值

c):遍历数组得到数组的每一个数

d):将数拼接 .append();方法

E)拼接完成后转换成Sting 字符串

f):遍历数组

public class StringBufferTest2 {

public static void main(String[] args) {

// 创建int[]数组

int[] arr = {1,2,3,4,5};

//调用方法

String str = concatString(arr);

System.out.println(str);

}

//创建一个将数组转变成字符串的静态方法

public static String concatString(int[] arr){

//定义一个StringBuffer对象，用来拼接字符串

StringBuffer buffer = new StringBuffer("[");

// 遍历数组，得到每一个元素

for (int i = 0; i < arr.length; i++) {

if (i == arr.length-1) {

//最后一个元素拼接

buffer.append(arr[i]).append("]");

} else {

//拼接

buffer.append(arr[i]).append(", ");

}

//返回结果

return buffer.toString();

}

看程序写结果：

String作为参数传递

StringBuffer作为参数传递

java参数传递

传递基本类型，形式参数的改变对实际参数没有影响

传递引用类型，形式参数的改变对实际参数有影响

String做为参数传递: 形式参数的改变对实际参数没有影响 , 因为String是一个常量

StringBuffer作为参数传递: 形式参数的改变对实际参数有影响

public class StringBufferTest4 {

public static void main(String[] args) {

//String str = new String("hello");

String str = "hello";

change(str);

System.out.println(str);// hello

//---------------

StringBuffer buffer = new StringBuffer("Java");

change(buffer);

System.out.println(buffer);//JavaJavaEEAndroid

}

//参数为字符串缓冲区

public static void change(StringBuffer buffer) {

buffer.append("JavaEE").append("Android");

}

//参数为字符串

public static void change(String str) {

str = "HelloWorld";

}

Arrays类概述

针对数组进行操作的工具类。

提供了排序，查找等功能。

成员方法

public static String toString(int[] a) 把各种数组转换为字符串

public static void sort(int[] a) 把各种数组进行元素排序

public static int binarySearch(int[] a,int key) 在各种类型数组中，进行执行数值的查找，折半查找方式(二分查找法)

注意：该方法的使用，前提要求给定的数组是一个有序的数组

public class ArraysDemo {

public static void main(String[] args) {

int[] arr = {1,5,9,3,7};

//public static String toString(int[] a) 把各种数组转换为字符串

String result = Arrays.toString(arr);

System.out.println(result);//[1, 5, 9, 3, 7]

//public static void sort(int[] a) 把各种数组进行元素排序

Arrays.sort(arr);

System.out.println("排序后：" + Arrays.toString(arr));//排序后：[1, 3, 5, 7, 9]

//public static int binarySearch(int[] a,int key)

// 前提要求给定的数组是一个有序的数组折半查找方式(二分查找法)

//int index = Arrays.binarySearch(arr, 7);

//int index = Arrays.binarySearch(arr, 9);

//System.out.println("arr数组中9的位置：" + index);

//int index = Arrays.binarySearch(arr, 0);//-1

//int index = Arrays.binarySearch(arr, 2);//-2

int index = Arrays.binarySearch(arr, 4);//-3

System.out.println("arr数组中4数据对应的位置：" + index);

}

排序方法:

冒泡排序代码实现

需求：

数组元素：{24, 69, 80, 57, 13}请对数组元素进行排序。

冒泡排序

相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处

public class ArrayTest1 {

public static void main(String[] args) {

int[] arr = {24,69,80,57,13};

System.out.println("排序前:");

System.out.println(Arrays.toString(arr));

//排序

bubbleSort(arr);

System.out.println("排序后:");

System.out.println(Arrays.toString(arr));

}

//冒泡排序

public static void bubbleSort(int[] arr){

//外层循环用来控制比较的次数

for (int i = 0; i < arr.length-1; i++) {

//i=0,1,2,3

//j < arr.length-1-i 为了避免重复比较

//j < arr.length-1 为了避免角标越界异常

for (int j = 0; j < arr.length-1-i; j++) {

//j=0,1,2,3

//arr[j] 和 arr[j+1]

// 0 1

// 1 2

// 2 3

// 3 4

if (arr[j] > arr[j+1]) {

//两个数交换

int temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

}

需求：

数组元素：{24, 69, 80, 57, 13}请对数组元素进行排序。

选择排序

从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

public class ArrayTest2 {

public static void main(String[] args) {

int[] arr = {24,69,80,57,13};

System.out.println("排序前:");

System.out.println(Arrays.toString(arr));

//排序

selectSort(arr);

System.out.println("排序后:");

System.out.println(Arrays.toString(arr));

}

//选择排序

public static void selectSort(int[] arr) {

//外循环控制比较的次数

//i=0,1,2,3

for (int i = 0; i < arr.length-1; i++) {

//内循环控制参与比较的元素

//j=i+1;

//j=1,2,3,4

//j=2,3,4

//j=3,4

//j=4

for (int j = i+1; j < arr.length; j++) {

//比较元素大小

if (arr[i] > arr[j]) {

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

}

java中的种基本数据类型:

基本类型包装类

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

Integer类概述

Integer 类在对象中包装了一个基本类型 int 的值

该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法

字段：

public static final int MAX_VALUE 最大值

public static final int MIN_VALUE 最小值

public class IntegerDemo {

public static void main(String[] args) {

//10十进制转换到其他进制

String s1 = Integer.toBinaryString(12);//1100

System.out.println(s1);

System.out.println( Integer.MAX_VALUE );

System.out.println( Integer.MIN_VALUE );

}

jdk1.5 自动装箱与自动拆箱

自动装箱: 把基本数据类型封装成对象

int --> Integer

自动拆箱: 把对象还原成基本数据类型

Integer --> int

public class IntegerDemo4 {

public static void main(String[] args) {

//jdk1.5之前

Integer in = new Integer(123);

int num = in.intValue();//获取Integer对象中的int数据

System.out.println(num);

//实现2个数相加

int sum = num + 10;

System.out.println(sum);

System.out.println("-------------------------");

//jdk1.5之后

Integer in2 = 123;//自动装箱 Integer in2 = Integer.valueOf(123);

int sum2 = in2 + 10;

* 步骤1

* int sum2 = in2.intValue() + 10;// 自动拆箱

System.out.println(sum2);

System.out.println("-------------------------");

Integer in3 = 123;// 自动装箱 Integer in3 = Integer.valueOf(123);

in3 = in3 + 10;

* in3 = in3.intValue() + 10; // 自动拆箱

* in3 = 123 + 10;

* in3 = 133; //自动装箱 in3 = Integer.valueOf(133);

System.out.println(in3);

}

Character类概述

Character 类在对象中包装一个基本类型 char 的值

此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然

键盘输入字符串，判断该字符串中有多个少大写、小写、数字的个数

方法：

public static boolean isDigit(char ch)确定指定字符是否为数字。

public static boolean isLowerCase(char ch)确定指定字符是否为小写字母。

public static boolean isUpperCase(char ch)确定指定字符是否为大写字母

public class CharacterDemo {

public static void main(String[] args) {

//键盘输入

Scanner sc = new Scanner(System.in);

System.out.println("请输入字符串:");

String str = sc.nextLine();

//定义3个变量

int numberCount = 0;

int maxCount = 0;

int minCount = 0;

for (int i = 0; i < str.length(); i++) {

//获取到每一个字符

char ch = str.charAt(i);

//Character c = ch;//自动装箱

//Character c = str.charAt(i);

//判断

if (Character.isDigit(ch)) {//是否为数字。

numberCount++;

} else if (Character.isLowerCase(ch)) {//否为小写字母

minCount++;

} else if (Character.isUpperCase(ch)) {//否为大写字母

maxCount++;

}

//打印

System.out.println( "numberCount:" + numberCount );

System.out.println( "maxCount:" + maxCount );

System.out.println( "minCount:" + minCount );

}

正则表达式：是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。

举例：校验qq号码.

1:要求必须是5-15位数字

2:0不能开头

public class RegexDemo {

public static void main(String[] args) {

//键盘录入

Scanner sc = new Scanner(System.in);

System.out.println("请输入5-15位QQ号码： ");

String qq = sc.nextLine();

//boolean flag = checkQQ( qq );

//System.out.println(flag);

//正则表达式方式

String regex = "[1-9][0-9]{4,14}";

boolean flag = qq.matches(regex);

System.out.println(flag);

}

//验证qq号码

public static boolean checkQQ(String qq) {

boolean flag = true;//记录qq号码是否正确

//判断长度

if (qq.length() >= 5 && qq.length() <= 15) {

//长度正确

//判断是否以0开头

if (qq.startsWith("0")) {

// 是0开头

flag = false;

} else{

//不是0开头

for (int i = 0; i < qq.length(); i++) {

//获取到每一位字符

char ch = qq.charAt(i);

//判断当前字符是否为数字

if (Character.isDigit(ch)) {

//这位是数字，继续判断下一位字符

} else {

//这位不是数字，说明qq账号不正确

flag = false;

break;

}

} else {

//长度错误

flag = false;

}

return flag;

}

Math:包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

字段：

public static final double E比任何其他值都更接近 e（即自然对的底数）的 double 值。

public static final double PI比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值。

方法：

public static double abs(double a) 返回 double 值的绝对值

public static double cbrt(double a)返回 double 值的立方根

public static double ceil(double a)返回比double 值大的最小整数

public static double floor(double a)返回比double 值小的最大整数

public static double max(double a, double b)返回两个 double 值中较大的一个

public static long round(double a) 四舍五入，取整

public static double sqrt(double a)返回正确舍入的 double 值的正平方根

public class MathDemo {

public static void main(String[] args) {

System.out.println(Math.E);//2.7

System.out.println(Math.PI);//3.1415926

//public static double abs(double a) 返回 double 值的绝对值

System.out.println("abs:"+Math.abs(3.14));

System.out.println("abs:"+Math.abs(-3.14));

//public static double cbrt(double a)返回 double 值的立方根

//8 = 2*2*2

System.out.println("cbrt:"+Math.cbrt(8.0));

//public static double ceil(double a)返回比double 值大的最小整数

System.out.println("ceil:"+Math.ceil(5.3));

System.out.println("ceil:"+Math.ceil(5.5));

System.out.println("ceil:"+Math.ceil(-5.5));

//public static double floor(double a) 返回比double 值小的最大整数

System.out.println("floor:"+Math.floor(5.3));

System.out.println("floor:"+Math.floor(5.5));

System.out.println("floor:"+Math.floor(-5.5));

//public static double max(double a, double b)返回两个 double 值中较大的一个

System.out.println("max:"+Math.max(-5.5, -3.5));

System.out.println("max:"+Math.max(5.5, 6.6));

//public static double pow(double a, double b)返回第一个参数的第二个参数次幂的值。

//返回 a 的 b次幂

System.out.println("pow:"+Math.pow(2, 3));

//public static long round(double a) 四舍五入，取整

System.out.println("round:"+Math.round(3.44));

System.out.println("round:"+Math.round(3.55));

System.out.println("round:"+Math.round(3.68));

//public static double sqrt(double a)返回正确舍入的 double 值的正平方根

// 4 = 2* 2

// 3 = 1.732 * 1.732

// 2 = 1.414 * 1.414

System.out.println("sqrt:" + Math.sqrt(4));

System.out.println("sqrt:" + Math.sqrt(3));

System.out.println("sqrt:" + Math.sqrt(2));

}

DateFormat类概述

DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。

是抽象类，所以使用其子类SimpleDateFormat

SimpleDateFormat构造方法

public SimpleDateFormat()

public SimpleDateFormat(String pattern)

成员方法

public final String format(Date date) : 将给定的日期对象转换成字符串对象

public Date parse(String source) :将给定的字符串转换为日期对象

y 年

M 年中的月份

d 月份中的天数

H 一天中的小时数（0-23）

m 小时中的分钟数

s 分钟中的秒数

public class DateFormatDemo {

public static void main(String[] args) throws ParseException {

//dateToString();

stringToDate();

}

//String --> 日期

public static void stringToDate() throws ParseException {

//定义时间字符串

String time = "2015-04-15";

//指定日期的格式

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

//把字符串解析成日期对象

Date date = sdf.parse(time);

//打印结果

System.out.println(date);

}

//日期 --> String

public static void dateToString() {

//创建日期对象

Date date = new Date();

//指定打印日期的格式

//SimpleDateFormat sdf = new SimpleDateFormat();

//public SimpleDateFormat(String pattern)

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");

//用指定的格式，将日期对象格式化成指定的格式结果

String time = sdf.format(date);

//打印结果

System.out.println(time);

}

ttuzanhua

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫