黑马程序员——常用类（Arrays、Date、基本包装类等）

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



1、Arrays工具类

1、Arrays是针对数组操作的工具类

2、成员方法

public static String toString(数据类型[] 变量名)	把数组变成字符串
public static void sort(数据类型[] 变量名)	对数组进行排序
public static int binarySearch(int[] arr,int value)	二分查找

  

2、System类

1、系统类，提供了静态的变量和方法供我们使用

2、成员方法

public static void exit(int value)	退出jvm，非0表示异常退出
public static long currentTimeMillis()	返回当前系统时间的毫秒值
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)	从指定源数的指定位置开始复制，赋值到目标数组的指定位置

3、基本类型的包装类

1、概述

     基本类型的数据我们只能使用值，不能做更多的操作。为了方便我们操作，java就把每种基本类型进行了包装。提供方法供我们使用

2、基本类型和包装类的对应关系

     

byte
short
int	Integer
long
float
double
char	Character
boolean

3、Integer构造方法

Integer(int num)
Integer(String s)	S必须是一个由数字字符组成的字符串

Integer 面试题：

                1、

              

              2、

                   

        如果字面量的值在-128到127之间，那么不会new新的Integer对象，而是直接引用常量池中的Integer对象，所以上面的面试题中f1==f2的结果是true，而f3==f4的结果是false。

4、String和int类型的转换

     1、String --> int    调用Integer类中的parseInt方法(常用)

          public static int parseInt(String s)

     2、int --> String 

          方法一：调用Integer中的toString()

                    public static String toString(itn i);

          方法二：调用String中的valueOf

                    public static String valueOf(int i)

          方法三：直接和空串连接

                    num +"";

5、JDK5以后的新特性

     1、自动装箱： 就是把基本数据类型直接赋值给引用数据类型.

                                基本类型  赋值给 引用类型      Integer integer = 1;

     2、自动拆箱：  就是把引用数据类型,拆分成基本数据类型进行运算.  

                                 引用类型  赋值给 基本类型      int i = new Integer(2);

        开发原则:如果对象不是自己创建的,是从其他地方传递过来的,那么在调方法之前要

先做一下不为null判断.

4、Date类(掌握)

1、概述

Date表示特定的时间，精确到毫秒

 

2、构造方法&成员方法(Date类的方法只知道这么多就够了)

构造方法
Date()	获取系统当前时间(常用)
Date(long time)	根据给定的毫秒生成一个时间(常用)
成员方法
Public long getTime()	获取毫秒值(常用)
Public void setTime(long time)	通过毫秒值设置日期

3、重要

     1、通过Date日期对象获取毫秒值

          Date date = new Date();

          long time = date.getTime();

     2、通过毫秒值获得Date日期对象

                    long time = ？？？L;    //毫秒值  注意：毫秒值后面加 L

                    Date date = new Date(time);

                    

                    Date d = new Date();

                    d.setTime(time);

5、SimpleDateFormat类

1、概述

     DateFormat:对日期进行格式化的类，提供了对日期进行格式化和对字符串进行解析的功能

     SimpleDateFormat是DateFormat的子类

2、构造方法&成员方法

 

构造方法
SimpleDateFormat()	无参的构造方法，采用默认日期格式(几乎不用)
SimpleDateFormat(String pattern)	有参构造，指定日期格式(常用)
成员方法
public final String format(Date date)	日期 -- >文本(常用)
public Date parse(String date)	文本 -- >日期

3、常用的模式字符串 & 组合(必须掌握，大小写搞清楚)

     

yyyy(四个小y)	年
MM(两个大M)	月
dd(两个小D)	月份中的天
HH(两个大H)	时
mm(两个小mm)	分
ss(两个小s)	秒
SSS(三个大S)	毫秒
常用的一个：yyyy-MM-dd HH:mm:ss:SSS

     格式转换：

  

public class DateFormatTest {
	public static void main(String[] args) throws ParseException  {
		
		Date d = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日     HH：mm：ss");
		// String format(Date date) 
		 String str = sdf.format(d);
		System.out.println(str);
		
		String s="2015年08月01日     17：15：24";
		// Date parse(String source) 
		 Date d1 = sdf.parse(s);
		 System.out.println(d1);
		
	}

}

6、Calendar类

1、概述

日历类，时间处理类

 通过get(字段值) 可以获取到一个日历字段，字段值都是静态常量，比如

字段值：

 Canlendar.DATE,Calendar.YEAR.....

 Calendar不能实例化，只能通过调用静态的方法getInstance()获取该类的对象(涉及到了单例) 

2、成员方法

int get(日历字段)	根据给定的日历字段获取值 日历字段：Calendar.YEAR,Calendar.DATE….等等，自己去看API
void set(年,月,日)	给日历设定指定的年，月，日
add(日历字段,值)	给指定的日历字段添加或者减去给定的值。取决于值的正负

3、注意事项

1、get(Calendar.MONTH)的值的范围是0-11，不是1-12

    

       //外国人的第一天是星期日

2、日期处理过程中能使用Calendar就不使用Date

例子：

public class February {
	
	//计算任意二月份有几天
	public static void main(String[] args) {
		
		//创建对象
		Calendar c = Calendar.getInstance();
		
		System.out.println("请输入年份：");
		Scanner sc = new Scanner(System.in);
		int year = sc.nextInt();
		
		//2其实是三月
		c.set(year, 2, 1);
		c.add(Calendar.DATE, -1);
		System.out.println(c.get(Calendar.DATE));
	}

}

4、案例

1、案例一：将日期格式化成指定格式文本

          1、采用默认格式格式化日期

                Date date = new Date();

                DateFormat dateFormat = new SimpleDateFormat();

                String result = dateFormat.format(date);

                输出：15-2-27 下午2:22

     

         2、采用指定格式格式化日期

                Date date = new Date();

                DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd  HH:mm:ss:SSS");

                String result = dateFormat.format(date);

                   System.out.println(result);

                   输出：2015-05-05  17:30:06:638

2、案例二：将文本解析成指定日期

    Date date = new Date();

    DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");

    Date result = dateFormat.parse("2011-01-01 11:11:11:111");

3、案例分析

题目：用户注册登陆案例：编写一个系统，需要如下功能：

     1、用户注册：注册完后保存起来，方便下次登陆

     2、用户登陆：登陆成功，提示登录成功，登陆失败，三次以后加入黑名单

        如果想让代码更符合面向对象的思想，要通过三个步骤分析：

        A、明确有几个类

        B、明确每个类的功能

        C、明确类与类之间的关系

      我们会把类分类：

        基本类（Bean）：对类简单的描述（属性、get/set方法、构造方法）

        操作类（Operator）：对基本类的操作，功能实现。

        

     分析：

        明确有几个类。

                用户类

                        用户基本描述类（实体类）

                        用户操作类（增删改查）

                测试类

        

             明确每个类的功能

                    用户类

                            成员变量：用户名、密码

                            成员方法：get/set

                            构造方法：无参构造、带参构造

                     用户操作类       

                            成员变量：？？

                            成员方法：登录、注册

                            构造方法：给不给都可

                     测试类

                            成员变量：无

                            成员方法：main方法

                            构造方法：无

            明确类与类的关系

                    在测试类中，键盘录入信息，调用用户操作类功能对用户对象进行操作。

     包结构

            pojo(domain、bean)：基本类

            dao

            impl 在dao.impl包中定义dao的具体实现方法

            test：存放测试的类

 

 

      分层（了解）

              cn.itcast.login.pojo

              cn.itcast.login.test

              cn.itcast.login.dao

              cn.itcast.login.dao.impl

 

      数据持久层（Dao）、业务逻辑层（Service）、表现层（struts/springMVC）

 

      表现层（struts/springMVC）分三层：MVC（Model、View、Controller）

 

      测试

     

4、升级用户注册，采用面向对象思想，并且分层(持久层，业务逻辑层，表现层)

5、面试题

1、byte常量池面试题

          Integer i1 = new Integer(127);

          Integer i2 = new Integer(127);
          System.out.println(i1 == i2);  // false
          System.out.println(i1.equals(i2));  // true

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

          Integer i3 = new Integer(128);
          Integer i4 = new Integer(128);
          System.out.println(i3 == i4);  // false
          System.out.println(i3.equals(i4)); // true
          Integer i5 = 128;
          Integer i6 = 128;
          System.out.println(i5 == i6);  // false
          System.out.println(i5.equals(i6)); // true

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

          Integer i7 = 127;
          Integer i8 = 127;
          System.out.println(i7 == i8); // true
          System.out.println(i7.equals(i8)); // true

          结论：java 为  byte范围内的值（-128 ~ 127） 提供了一个常量池，只要 是这个范围内的值都可以从常量池里面获取， 直接赋值给Integer，

2、String类面试题

          1.     
          public static void main(String[] args) {
               String s = "abc";
               change(s);
               System.out.println(s);
          }
          public static void change(String s) {
               s += "hello";
          }
          注：基本类型 -- 形式参数改变不影响实际参数。
               引用类型 -- 形式参数改变直接影响实际参数。
               但是，字符串是特殊的引用类型，实参传递到形参时，实际上是把值传递给了形参，而不是地址值。
         
          -- 如果是StringBuffer.则打印的是abchello。StringBuffer容量可变。
          

          2. 字符串拼接问题
          public static void main(String[] args) {
               String s1 = "a";
               String s2 = "b";
               String s3 = "ab";
               System.out.println(s3 == s1 + s2); // false
               System.out.println(s3 == "a" + "b"); // true，常量的运算会在编译期间就计算，所以"a"+"b"在编译后就是"ab"
          }

    常量相加会直接累加,然后在常量池中找对应的值，有则使用，没有则创建一个使用。

    变量相加会重新开辟一块空间，用于保存结果。

      

六、常用API的方法

    1：Object(重点)

         toString():为了让对象的显示有意义，一般重写该方法。

         equals():默认比较的是地址值，一般重写该方法，按照自己的需求。

        关于==做比较的问题

            基本类型的比较:比较的是具体的值

            引用类型的比较:比较的是对象的地址值

    2：Math

 

    3：Random

    4：Scanner

         nextInt():获取int类型

         nextLine():获取String类型

    5：String(重点)

         把day13总结里面的几种功能补齐中文意思在看一遍。

    

    6：StringBuffer(重点)

         append():添加

         insert():在指定位置添加

        StringBuffer()

        创建一个StringBuffer对象默认长度是16

        StringBuffer( int capacity )

        创建一个指定长度的StringBuffer对象.

        StringBuffer( String str)

        相当把String类型转换成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)

        从指定索引开始截取到指定索引

    7：System

         exit():退出

         public static long currentTimeMillis()  

         返回当前时间的毫秒值

    8：Arrays

         sort():排序

         binarySearch():二分查找

    9：Integer(重点)

         parseInt(String s):把String -- int

   

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