黑马程序员_java_API总结

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


一、String类
（1）java定义了两个方法来封装字符串，一个是String类，一个是StringBuffer类。
字符串即一连串的字符。
注：空串与null的区别
举例:字符串就是羊肉串,空串就是签子,null的话就是把签子扔掉.


（2）String类构造方法


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


 * String(byte[] bytes, int index, int length)
把一个字节数组的一部分转换为字符串  (从指定索引开始,截取指定长度)
 * String(char[] value) 
把一个字符数组转换成字符串
 * String(char[] value, int index, int length) 
把一个字符数组的一部分转换为字符串  (从指定索引开始,截取指定长度)




创建字符串对象的方式：


第一种  String s = new String("abc");
第二种  String s ="abc";


留心：数组和字符串分别通过什么方式获长度？
数组:使用的是数组的  .lenght 属性（是特别的）
字符串:使用的是字符串的 .length()方法


（3）String类的判断功能
1、
**boolean equals(Object obj) ：
判断两个字符串是否相同(区分大小写
)
boolean equalsIgnoreCase(String str) :
判断两个字符串是否相同(不区分大小写)


**boolean contains(String str)：
判断这个字符串是否包含给定的字符串


**boolean startsWith(String str)：
判断字符串是否以给定的字符串开始


**boolean endsWith(String str)：
判断字符串是否以给定的字符串结束


**boolean isEmpty()：
判断字符串是否为空


（4）String类的获取功能
int length()
获取字符串的长度


char charAt(int index)
获取指定索引处出现的字符


int indexOf(int ch)
获取字符串中指定字符第一次出现的索引


int indexOf(String str)
获取字符串中指定字符串第一次出现的索引


int indexOf(int ch, int fromIndex)
返回在此字符串中第一次出现指定字符处的索引，
从指定的fromIndex开始搜索。


int indexOf(String str, int fromIndex)
返回指定字符串中第一次出现指定字符串处的索引,从指定位置开始搜索


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


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


字符串中找索引有一个原则:包左不包右.




（5）String类的转换功能
byte[] getBytes()
把字符串转换成字节数组
char[] toCharArray()
把字符串转换成字符数组
static String ValueOf(char[] chs)
把字符数组转换成字符串


static String valueOf( int i )
把(基本类型)int类型的一个数据转换为字符串类型


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


String toUpperCase()
把字符串转换为大写


String concat(String str)
把两个字符串拼接.


注：字符串大小写转换练习


 字符串：helloWorld   结果为：Helloworld
 思路：A获取首字母字符串
  B获取除首字母的字符串
  C把A转大写,把B转小写,再拼接


（6）String类的其它功能
String replace(char oldChar, char newChar )
用指定新的字符替换旧的字符


String replace(String oldString, String newString)
用指定新的字符串去替换老的字符串(新串和老串的长度可以不同)


String[] split(String regex)
以指定的字符串为标记切割字符串,返回一个字符串数组.


String trim()
去除字符串两端的空格


int compareTo(String str)
用字典顺序比较两个字符串.如果相同返回0.


（7）String常见问题


1、如何理解字符串一旦初始化就不可以被改变。
String s = "hello";
s += "world";
System.out.println(s);  


不可以被改变说的是常量池中的值,并不是引用s(s是可以重新被赋值的)


2、
String s1 = new String("abc"); 
String s2 = "abc"；
s1、s2有区别吗？
第一种方式：第一种方式在内存中存在两个"abc"字符串,一个是在常量池中,一个是在堆内存当中.
第二种方式：在内存中只存在一个"abc"在常量池中.


3、以下程序运行会出现什么结果
String s1 = "";
String s2 = null;
System.out.println(s1.isEmpty()); //true
System.out.println(s2.isEmpty()); //NullPointerException空指针异常




（8）案例：模拟用户登录
思路：
A：假设已经存在有了用户名密码,用String 定义就OK了
B：键盘录入数据用户名和密码.
C：把数据进行比较,如果正确就进入,不正确继续判断
D：给三次机会,明确了循环次数,用for循环解决


C、代码：
if(userName.equals(name) && passWord.equals(pwd)){
System.out.println("输入正确，登陆成功");
break;
} else{
//如果不匹配则提示相应的信息，并告知剩余次数。
//三次都输错，直接冻结账号
if ((2-i)==0) {
System.out.println("账号已被锁定，请与老刘联系");
}else {
System.out.println("登陆失败，您还有"+(2-i)+"次机会");
}


（9）案例：大串中查找小串出现的次数
思路回顾：


A：定义两个字符串。一个大串，一个小串。
定义一个统计变量，次数默认为0。


B：在大串中查找一个小串第一次出现的索引：indexOf()
如果存在，就返回索引。这个时候，我们把统计变量++。
如果不存在，就返回-1。这个时候，我们就直接把统计变量的值返回即可。


C；把上次查找到的小串的第一个字符的索引记录住。
   然后从这个索引+小串长度处开始截取大串，重新赋值给以前的大串。
   回到B。


二、Arrays工具类
（1）数组排序（冒泡排序原理分析）


     A.冒泡排序的原理：
     相邻元素两两比较,大的往后走
 第一次比较后最大值就在最大索引处了
第二次继续比较完之后第二大的值就在第二大的索引处
......


     B.数组排序（冒泡排序思路代码）：


public static void bubbleSort(int[] arr) {
// 外循环控制次数
for (int x = 0; x < arr.length - 1; x++) {
// 内循环控制每一次的比较过程
/*
* 第一次，所有元素都参与比较，也就是0个元素不参与。 第二次,有1个元素不用参与。 第三次，有2个元素不用参与。 ...
*/
// -1是为了防止索引越界
// -x是为了减少比较的次数
for (int y = 0; y < arr.length - 1 - x; y++) {
if (arr[y] > arr[y + 1]) {
// 数据交换
int temp = arr[y];
arr[y] = arr[y + 1];
arr[y + 1] = temp;
}
}
}
}


     C.对字符串中的字符进行排序：


思路：
1、可以通过toCharArray( )方法把字符串转换成字符数组
2、对这个字符数组进行排序
3、把排序后的数组转换成字符串,String类的构造方法,也可以用valueOf();


(2)数组二分查找
前提条件：数组必须是有序的


    思路：A、把要查找的数据从中间位置查找,如果相同则直接返回索引,如果不同,看是大了还是小了
 B、如果大了在右边继续进行A的操作,如果小了在左边进行A的操作.


（3）、Arrays工具
    Arrays是数组的封装类。


（4）Arrays工具类的方法使用


*public static String toString( int[] a )
把一个整形的数组转换成字符串


*public static void sort( int[] a )
把数组进行排序


*public static int binarySearch ( int[] a, int key)
对数组进行二分查找.
三、System类
（1）System类常用方法使用
*public static void exit ( int status) 
退出虚拟机


**public static long currentTimeMillis()  
返回当前时间的毫秒值


（2）System类中的复制数组的方法
*public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length )
从指定数组中复制一个数组,复制从指定位置开始,到目标数组的指定位置结束.


四、StringBuffer类
（1）StringBuffer类也称为字符串缓冲区


    1、问题：StringBuffer和String的区别？
    String 一但被赋值不可以被改变,而StringBuffer是可以被改变的 (因为它是使用了一个缓冲区机制)


    2、创建StringBuffer对象的三种方式
    StringBuffer()
    创建一个StringBuffer对象默认长度是16


    StringBuffer( int capacity )
    创建一个指定长度的StringBuffer对象.


    StringBuffer( String str)
    相当把String类型转换成StringBuffer类型.


    3、
    public int length ()   
    获取实际长度


    public int capacity ()
    获取理论长度


    4、想把String和StringBuffer互相转换怎么办？
    使用它们对应类中的构造方法可以实现.


（2）StringBuffer的添加功能


public StringBuffer append ( int i )
在末尾追加元素


public StringBuffer insert ( int index, String i )
在指定索引处增加元素.


---------------------------------------------------------------------------------------------------------------
（3）StringBuffer的删除功能


StringBuffer deleteCharAt ( int index )
删除指定索引处的字符


StringBuffer delete ( int start , int end )
删除从位置开始到指定索引结束


StringBuffer replace(int start, int end, String str)
 把指定索引到指定索引之间的字符用一个字符串替换


String substring(int start)
从指定索引开始截取到末尾


String substring(int start, int end)
从指定索引开始截取到指定索引


StringBuffer reverse()
把字符串反转


注：把字符串反转
方式1
A：把字符串转换成字符数组
B：把字符数组倒序输出


方式2
A：把String类型先转换成StringBuffer类型. 构造方法
B：调用反转功能
C：把StringBuffer类型在转换成String类型.构造方法


---------------------------------------------------------------------------------------------------------------
（4）String类的常用问题
理解：
基本类型：形式参数的改变不会影响实际参数(因为传递的是实际的值)
引用类型：形式参数的改变会影响实际参数(传递的是地址值)
但是：String类型除外


结论：
常量相加会直接累加,然后在常量池中找对应的值去使用.
变量相加会重新开辟一块空间.


五、包装类
包装类可以将基本类型的值包装为引用类型的对象。
（1）Integer类的构造方法
基本类型   包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean


通过Integer的构造方法可以把String类型转换成Integer类型
注意:这个字符串必须是由纯数字组成才可以.


（2）Integer类的概述和使用
Integer类是基本类型int的包装类


public static String toBinaryString( int i )
把int类型数据转换成二进制的变现形式


public static String toOctalString( int i )
把int类型数据转换成八进制的变现形式


public static String toHexString( int i )
把int类型数据转换成十六进制的变现形式




（3）String和int的相互转化
int转成String
方式1（理解）int num = 100;
String s = 100 + "";
方式2（掌握）String s = String.valueOf(num);
方式3（理解）Integer i = new Integer( num );
String s = i.toString();
方式4（掌握）String  s= Integer.toString( num );


String转成int
方式1（理解）String s = "123";
Integer i = new Integer ( s );
int number = i.intValue();


  **方式2:（掌握）int number = Integer.parseInt( String s );


（4）把字符串中的数字字符排序


思路：
A：把字符串转换成字符串数组
B：把字符串数组转换成int数组
C：把int数组进行排序
D：把排序后的数组在转换成字符串


（5）JDK5以后Integer类的新特性
自动装箱：就是把基本数据类型直接赋值给引用数据类型.
自动拆箱：就是把引用数据类型,拆分成基本数据类型进行运算.


开发原则:如果对象不是自己创建的,是从其他地方传递过来的,那么在调方法之前要
先做一下不为null判断.


六、常用API的方法
1：Object(重点)
toString():为了让对象的显示有意义，一般重写该方法。
equals():默认比较的是地址值，一般重写该方法，按照自己的需求。


2：Math
Math.ceil(double a)向上取整
Math.floor(double a)向下取整
Math.sqrt(double a) 平方根
Math.pow(double a, double b) 次方
3：Random
new Random().nextInt(int n)生成一个0~nd的随机数


4：Scanner
nextInt():获取int类型
nextLine():获取String类型




七、Date类


（1）Date类的使用


1、Date()
获取当前的时间,以时期形式(对象)


2、Date( long time )
通过给定的毫秒值获取日期对象


3、public long getTime();
根据日期对象获取相对应的毫秒值


4 public void setTime(long time);
设置日期对象的毫秒值.


（2）DateFormat类格式化简单使用
Date --> String 转换过程叫 格式化。


重点代码：
//创建日期对象
Date d = new Date();
//创建格式对象
SimpleDateFormat sdf = new SimpleDateFormat();
String s = sdf.format( d );
System.out.println( s );


（3）SimpleDateFormat格式化解析指定格式的日期


1、想把日期转换成我们想要的指定模式需要用到哪个构造方法？
需要用到SimpleDateFormat的带参构造,然后把要指定的格式传入就可以了.


注意:从字符串>日期 需要注意 你指定的日期格式要与字符串的格式相匹配.


（4）Calendar类的概述和使用


1、 Calendar c = Calendar.getInstance();
这一步是创建对象的操作创建了Calendar对象(更严谨的说这一步创建了Calendar的子类对象.)


八、重点案例
（1）计算某一年的2月份有多少天
涉及到的方法


1、public final void set ( int year, int month, int date );
设置字段,中的年 月 日.


2、public abstract void add ( int field, int amount );
根据日历的规则,为给定的日历字段增加或减少指定的天数.、


（2）通过键盘录入学生
对对象数组的理解
其实就是原来定义这个数组中存储的数据类型是基本类型(比如说int [])
现在定义的数组类型是引用数据类型(比如说Student[])


[1]用户登陆注册的分析
在写一个工程的时候，如果你想让你的代码更符合面向对象的思需要有明确的框架？
A：明确有几个类
B：明确每个类功能。
C：明确类与类之间的关系


[2]用户登陆注册的包划分


一般写一个项目的时候要分包两种方式
A：按模块分
B：按操作分
cn.itcast.dao
cn.itcast.impl
www.itcast.cn
com.baidu


[3]用户描述类的实现
建包步骤
1、建用户描述类的包 package cn.itcast.pojo;
同时在包下创建User用户类


2、用户操作类的包 package cn.itcast.dao;
同时在包内创建UserDao接口


3、创建用户实现类的包 package cn.itcast.dao.impl;
同时在包内创建UserDaoImpl实体类


4、测试类的包 package cn.itcast.test;
同时在包内创建UserTest实体类。


[4]用户操作类的实现
如果传递的参数过多我们一般采取什么措施？


一般我们采取传递对象的形式,因为对象中可以包含这些参数.


[5]用户测试类的实现
思路：
1、搭建欢迎界面（注册，登陆，退出）


2、用switch来判断用户的选择项


3、根据用户的选择项进行相应的操作。登陆、注册或者退出。


[6]代码
【1】
package cn.itcast.pojo;
/**
 * 这是一个用户描述类
 * @author itcast
 *
 */


public class User {


// 用户名
private String userName;


// 密码
private String passWord;


// 邮箱
private String email;


// 电话
private String phone;


//无参构造
public User() {
super();
}

//有参构造
public User(String userName, String passWord, String email, String phone) {
super();
this.userName = userName;
this.passWord = passWord;
this.email = email;
this.phone = phone;
}

//构建set,get方法
public String getUserName() {
return userName;
}


public void setUserName(String userName) {
this.userName = userName;
}


public String getPassWord() {
return passWord;
}


public void setPassWord(String passWord) {
this.passWord = passWord;
}


public String getEmail() {
return email;
}


public void setEmail(String email) {
this.email = email;
}


public String getPhone() {
return phone;
}


public void setPhone(String phone) {
this.phone = phone;
}


}
【2】
package cn.itcast.dao;


import cn.itcast.pojo.User;
/**
 * 这是一个用户接口
 * @author itcast
 *
 */
public interface UserDao {
/**
* 这是用户登录功能
* @param userName
* 用户名
* @param passWord
* 密码
* @return 返回登录是否成功
*/
public abstract boolean isLogin(String userName,String passWord);
/**
* 这是用户注册功能
* @param user
* 要注册的用户
*/
public abstract void regist(User user);
}
【3】
package cn.itcast.dao.impl;


import cn.itcast.dao.UserDao;
import cn.itcast.pojo.User;


public class UserDaoImpl implements UserDao {
private static User[] users = new User[5];
private static int index = 0;


// 这个是登录比较功能
@Override
public boolean isLogin(String userName, String passWord) {
// TODO Auto-generated method stub
boolean flag = false;
/**
* 遍历数组
*/
for (int i = 0; i < users.length; i++) {
User user = users[i];

// 判断用户是否为空
if (user != null) {
if (user.getUserName().equals(userName) && user.getPassWord().equals(passWord)){
flag = true;
break;
}
}
}
return flag;
}


// 注册用户
@Override
public void regist(User user) {
// TODO Auto-generated method stub
users[index++] = user;
}


}
【4】
package cn.itcast.test;


import java.util.Scanner;


import cn.itcast.dao.impl.UserDaoImpl;


import cn.itcast.pojo.User;


public class UserTest {
public static void main(String[] args) {
while (true) {
System.out.println("欢迎来到itcast");
System.out.println("1:登录");
System.out.println("2:注册");
System.out.println("3:退出");
System.out.println("请选择："); 
Scanner sc = new Scanner(System.in);
String line = sc.nextLine(); 

switch (line) {
case "1":
System.out.println("欢迎来到登录界面");
System.out.println("请输入用户名：");
String username = sc.nextLine();
System.out.println("请输入密码：");
String password = sc.nextLine();
// 多态用法
// UserDao ud = new UserDaoImpl();
// 具体类用法
UserDaoImpl udi = new UserDaoImpl();
boolean flag = udi.isLogin(username, password);
if (flag) {
System.out.println("开始玩游戏吧");
System.exit(0);
} else {
System.out.println("登录失败,返回主界面");
}
break;
case "2":
System.out.println("欢迎来到注册界面");
// 键盘录入用户信息
System.out.println("请输入用户名：");
String newUsername = sc.nextLine();
System.out.println("请输入密码：");
String newPassword = sc.nextLine();
System.out.println("请输入邮箱：");
String newEmail = sc.nextLine();
System.out.println("请输入电话：");
String newPhone = sc.nextLine();


// 把数据用对象进行封装
User user = new User();
user.setUserName(newUsername);
user.setPassWord(newPassword);
user.setEmail(newEmail);
user.setPhone(newPhone);


// 创建用户操作类对象
UserDaoImpl newUdi = new UserDaoImpl();


// 调用注册方法
newUdi.regist(user);
System.out.println("注册成功");
break;
case "3":
// System.out.println("谢谢你的使用");
// System.exit(0);
// break;
default:
System.out.println("谢谢你的使用");
System.exit(0);
break;
}
}
}


}