java之旅之常用类

xuchou1990

于 2016-12-12 18:45:08 发布

阅读量228

点赞数

分类专栏： JAVA基础

本文链接：https://blog.csdn.net/xuchou1990/article/details/53585839

版权

JAVA基础专栏收录该内容

15 篇文章 0 订阅

订阅专栏

常用类

字符串：常用字符串属性、方法；
包装类与自动装箱，自动拆箱
日期类
数学类，Math.

1、字符串：
（一）

String str = “hello”; str 指向“hello”常量（static）对象，被放在数据段字符串常量池（除此之外还有线程池、）；这样提升性能，字符串会大量被使用，因此进行预加载；

String str2 = “hello”;

String str1 = new String(“hello”) ;

String str3 = new String(“hello”) ;

str1 指向在堆内存中创建的对象“hello”；因此，str1、str3与str不相等；但是str与str2相等；

区分：equal 与 == ； ==对比的是变量中的值； equal对比的是两个对象的内容相同；【equal重写方法在继承中有记录】；
（二）

String str2 = new String（“hello！”）这里产生了多少个字符串对象（2个-str2和hello”）；这里产生了多少个对象（3个+类对象）；
（三）

String对象内容不可变：

str0 = str0 + “ world” 则str0 指向了一个新对象“hello world” 原来的hello指向被取消；

String tst = null； //空没对象，会报空指针异常；

String tst = “”； //空串有对象，不会报空指针异常；

字符串非空判断，不是空，也不是空串；

【案例】if（ tst ！= null && ！tst.equal（“”））顺序不能换；
StringBuffer :

append（“sbsbcd”）方法：仅往字符串后面拼接；

insert（index，“ jsa”）方法：往字符串的制定位置插入；

（四）常用字符串方法属性：

String str = “hello！”

A、跟字符串有关：

System.out.println( str.length( ) ); 打印str的字符串长度；

char [] str = array.toCharArray( );把String对象转换成char 数组；

System.out.println( str.lcharAt(5 ) ); 取第几个下标位置的字符；

System.out.println( str.indexOf( ‘e’ ) ); 取某个字母首次出现的下标，没出现返回-1；

System.out.println( str.lastIndexOf( ‘e’ ) );得到某个字符最后一次出现的位置的第一个字符位置下标；没有返回-1；

B、跟字母有关：

System.out.println( str.toUpperCase( ) ); 得到一个新的全大写的STR内容的新字符串；

System.out.println( str.toLowerCase( ) ); 得到一个新的全小写的STR内容的新字符串；

System.out.println( “HEllo”.equalsIgnoreCase (str ) ); 忽略（Ignore）大小写进行比较，

System.out.println( “hEllo”.compareTo (“hello”) );进行字典顺序比较，得到第一个不同的Aism值的差值，每个相同则比较长度差；

System.out.println( “hEllo”.compareToIgnoreCase (“hello”) );忽略大小写进行字典顺序比较，得到第一个不同的Aism值的差值，每个相同则比较长度差；

C、跟技巧有关的方法：

System.out.println( str.contains (“lo”) );判断一个String对象是否包含另一个子串

System.out.println( str.startsWith (“he”) );判断一个String对象以什么开头

System.out.println( str.endsWith (“lo”) );判断一个String对象以什么结尾；

System.out.println( str.replace ( “ll” , ‘o’ ) );将String对象中的某个子串替换成另一个字符串

System.out.println( str.replaceAll ( ‘l’ , “fuck” ) ); 在之上基础上支持正则表达式；

System.out.println( str.replaceFirst( ‘l’ , “fuck” ) );将String对象中首次出现的某个子串替换成另一个String对象；

D、特殊方法：

1、trim方法，去掉String的前后空格； String input = “ fuck you ”
养成习惯：接收到一个输入的时候，首先进行一个trim；

使用：String input = “ * * ”

String newStr = input.trim（）；

system.out.println（ newStr.length（））；

2、split方法，根据分隔符拆分字符串：通常用在网络传输中（内容/QQ号/字体/时间）接受打印出来；【特别注意】：数组长度 = 分隔符+1（分隔符在最后或者后面连续分隔符则不会拆，不计算分隔符个数；）

String birthday = “1987-12-03”；

String[] array = birthday.split( “-” );

system.out.println( array[ 2 ] ); 03

3、mathces方法，做正则表达式效验：

正则表达式：regex；用字符串定义的一个模板，本身也是一个字符串；

正则表达式调用顺序：找到正则表达式，点正则表达式就进来了；

Pattern p = Pattern.compile(“a*b”); Matcher m = p.matcher(“aaaaab”);
boolean b = m.matches();

在输入邮箱中，用正则表达式进行校验邮箱格式是否正确；（**@126.com/cn/edu）

细节：

1、任何一个字符串都是正则表达式，“hello”就是一个，它固定的格式只有“hello”自身才能满足；

【案例】：正则表达式全部核对；

String phoneNum = new Scanner( System.in ).next( );

String regexP = “83201234”;

if( phoneNum.matches( regexP ) ){

打印“这是一个正确的号码”

}else

打印“这是一个错误的号码”

}

2、要想更多满足情况，必须加入模糊匹配；（[ ] ( ) { }）

[ ]：一个方括号代表一个字符；在内部填写这些位置可以放那些符号 “8320[0123456789] [0-9] [0-9a-zA-Z] [\d]”
“-“表示x到x \d：表示0-9
^0-9：除了0-9

( )：代表分组可选，（ | ），在圆括号中进行分组，每一组都可以出现；”（8320[ 0-9 ]{4} | 8320120 | 8320110 | 8320114）” 或者用 “8320( [ 0-9 ]{4} | 120 | 110 | 114 )” 还可以 “8320( [ 0-9 ]{4} | 1[12]0 | 114 )”

{ } :{ m,n }：至少出现m次,最多出现n次，
{m, }至少m次
[ ]中的数字； *出现任意次
+ 一次或者多次
“（200 | 1[0-9]{2} | [1-9] [0-9]?）00”

2、System类：final类，静态属性和方法；

常用属性：in 、 out、 err:标准错误输出流；

常用方法：currentTimeMillis（）

exit（）非0 的状态码表示异常终止；

getProperties( ) 获取当前系统属性；

gc( ) 垃圾回收器；

arraycopy（）复制数组；

Runtime类：不能创建自己的实例，可以通过Runtime类的静态方法getRuntime（）获取与之关联的Runtime对象；

当前处理器数量： rt.availableProcessors( )

空闲内存数：rt.freeMemory( )

总内存数：rt.totalMemory( )

可用最大内存数：rt.maxMemory( )

2、包装类：（如何查API/DOC）

（一）基本数据类型—包装类—String（两两自由转换）：

1、int—Integer；

int a = 100 ;

Integer in = new Integer(a); //标准思考：构造方法传入int类型；

Integer in = a ； //自动封箱，JDK1.5以后的语法糖；

2、Integer—int；

Integer in = 205;

int a = in. intValue; // 思考方法：不传参的返回值为int类型的方法；没有String关键字【String跟类有关，跟对象无关，而我们调用的方法与对象有关；】；

int b = in ; //自动拆箱；JDK1.5以后的语法糖；

3、String–Integer

String str = “123”;

Interger in = new Interger( str );

4、Integer—String

Integer in = 345

String str = in.toString（）；

String str0 = in + “”； //当对对象做字符串做拼接操作时，相当于默认调用tostring方法；

5、int—String对象

int a = 120；

//String str = new String（） ;

//str.valueOf( a ); //产生为静态的；

//String str =Integer.toString( a ); 该类中的tostring方法重写了Object中的；

//String str = a + “”;

6、String—int

String str = “2500” ;

// int a = new Integer( str );

// int a = Integer.parseInt(str);

package com.lovo.integer;

public class TestInteger {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //包装类的作用：1、丰富了基本数据类型只能存放值的问题，还可以提供大量的方法或常量；
        //             2、包装类充当了基本数据类型和引用数据类型的桥梁
        //应用层面：必须掌握基本数据类、包装类型和String类型三者的任意转换

        //1、基本和包装之间的转换
        //1-1、基本转包装
//      int a = 100;
//      Integer in = new Integer(a);//标准做法
//      in = 250;//自动封箱---JDK1.5以后提供

        //1-2、包装转基本
//      Integer in = 300;
//      int b = in.intValue();//标准做法
//      b = in;//自动拆箱---JDK1.5以后提供

        //2、包装和String之间的转换
        //2-1、String转包装
//      String str = "125";
//      Integer in = new Integer(str);

        //2-2、包装转String
//      Integer in = 325;
//      String str = in.toString();//标准做法
//      String str1 = in + "";//其实本质还是在调用in的toString方法

        //3、String和基本类型之间的转换
        //3-1、String转基本
//      String str = "275";
//      int i = Integer.parseInt(str);//将字符串String转换为基本数据类型

        //3-2、基本转String
        int i = 78;
        String str = Integer.toString(i);
        String str1 = i + "";
        System.out.println(str);
    }

}

package com.lovo.string;

public class TestStringBufferBuilder {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //StringBuffer是一个全新的类型，与String没有继承关系
        //StringBuffer的出现是为了解决String内容不可变的问题，它是可变的
        //它绝不享受String的特殊语法（什么+号拼接、自解赋值String常量）
        //它的方法完全没有String丰富，大部分方法都是和拼接或删除有关，需要传入位置下标
        StringBuffer sb = new StringBuffer("hello");
        StringBuffer sb2 = sb.append("world");//StringBuffer在字符串末尾做拼接
        sb2 = sb2.insert(5, " ");//StringBuffer在字符串任意位置做拼接
        System.out.println(sb2);


        //StringBuilder也是一个全新的类型，与String没有继承关系
        //StringBuilder的出现是为了解决String内容不可变的问题，它是可变的
        //它绝不享受String的特殊语法（什么+号拼接、自解赋值String常量）
        //它的方法完全没有String丰富，大部分方法都是和拼接或删除有关，需要传入位置下标
        StringBuilder sb0 = new StringBuilder("ByeBye");
        StringBuffer sb1 = sb.append("world");//StringBuffer在字符串末尾做拼接
        sb1 = sb1.insert(5, " ");//StringBuffer在字符串任意位置做拼接
        System.out.println(sb1);

    }

}

（二）怎么查找API里面有自己需要的类和方法：

首先判断问题：是要变为一个实例化对象吗？那需要传参吗？有没有对象要调用方法的，需要传实参吗？

其次，是本类型通过方法转化类型；类的方法中有没有（形参、返回类型，是否为静态，对象有关）

在API中还会常遇到过时的方法，往往是这个方法内部的实现部分的性能过于复杂或者安全过低，因此不再推荐使用；

3、时间日期类：

long time1 = System.currentTimeMillis( ); 从时间原点（1970年1月1日到现在的毫秒数；）

用法：用于记录一段程序执行的时间，开始记录一下；结束记录一下；减去则得到结果；【千万次计算用15毫秒；加入输入输出仅1000次耗时使用62毫秒；–输入输出计算机的运算瓶颈】

Date：simpledateformat时间格式化输出的好工具；【类：simpleDate】

Date now = new Date();

simpledateformat sdf = new simpledateformat（“yyyy-mm-dd
hh:mm:ss”）

String msg = sdf.format( now ); “yyyy年mm月dd日
HH：mm：ss”

Calendar：日历类（抽象类，不能实例化；直接子类只有一个公历类）实例化

Calendar ca1 = new GregorianCalendar（）；

Calendar ca1 = Calendar.getInstance（）；直接返回一个公历对象；

使用打印出某年，某月，某日的时间【西方：月从0开始；星期从周日开始】

【输入年月日 int year int moth int day】

Calendar ca1 = Calendar.getInstance（）；// 实例化一个日历对象；

cal.set( Calendar.YEAR,year );

cal.set( Calendar.MONTH,month-1 );

cal.set( Calendar.DATE,day );

int msg = ca1.get( Calendar.DAY＿OF＿ WEEK);

打印（msg）； //但是这个日期的周几出错，因为从周日开始；可以使用SWitch()语句进行判断，打印出结果；或者；

使用 Date birthDay = cal.getTime(); //调用get方法将cal 转换为Data类型

String result = new SimpleDateFormat(“E”).format(birthDay); 使用工具打印出其周几；

package com.lovo.date;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;


public class TestDate {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //可以直接通过这个方法获得当前时间的毫秒数
//      long now1 = System.currentTimeMillis();
//      int num = 0;
//      for(int i = 0; i < 1000; i++){
//          System.out.println("I love you");
//      }
//      long now2 = System.currentTimeMillis();
//      System.out.println(now2-now1);


        //Date类用来封装了时间日期
        //由于Date这个类型出现的较早，经历了时间原点的变迁，以及JDK版本的变迁，所以有很多的过时方法
        //Date目前的使用场景：1、获取程序运行的当前时间还是用Date最方便;
        //                  2、SimpleDateFormat类可以自定义格式化输出日期时间字符串
        //                  3、Date在各版本中都可以使用，因而成为表示时间日期的首选
        Date now = new Date();//获取当前时间的Date对象
        now = new Date(0L);//根据传入的long类型毫秒数表示时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 a hh:mm:ss:SSS  E");
        String msg = sdf.format(now);
//      System.out.println(msg);


        //Date短处：1、根据指定的年月日时分秒来设置对象的值----方法已经都过时了
        //         2、难于取出时间日期的一部分（比如年、月）进行单独的时间运算。
        //解决方案：使用Calendar这个替代类进行操作
        //Calendar类---日历类
        Calendar cal = Calendar.getInstance();//使用设计模式帮助我们直接获取到Calendar的子类对象，里面对应的就是当前日期时间
        int year = 1992;
        int month = 2;
        int date = 14;
        cal.set(year, month - 1, date);
        //Calendar ---> Date
//      Date birthday = cal.getTime();
        Date birthday = new Date(cal.getTimeInMillis());
        String dayOfWeek = new SimpleDateFormat("E").format(birthday);
        System.out.println(dayOfWeek);
    }

}

数学类：没有new概念；

作业解析：

package com.lovo.homework;

public class TestHome {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //从字符串"dfdafadergzafgrargsfgsreystgafijoomoafafkpkpojosyiuqhreaw2334sdfsafa"
        //1、通过toCharArray方法，把字符串转换为char[]，然后通过循环排查
//      String str = "dfdafadergzafgrargsfgsreystgafijoomoafafkpkpojosyiuqhreaw2334sdfsafa";
//      char[] array = str.toCharArray();
//      int num = 0;
//      for(int i = 0; i < array.length - 2; i++){
//          if(array[i] == 'a' && array[i+1] == 'f'){
//              num++;
//          }
//      }
//      System.out.println(num);

        //2、通过split方法进行字符串拆分，通过拆分后的数组长度判断有多少个af分隔
//      String str = "afdfdafadergzafgrargsfgsreystgafijoomoafafkpkpojosyiuqhreaw2334sdfsafafaf";
//      int num = 0;
//      while(str.endsWith("af")){
//          num++;
//          str = str.substring(0, str.length() - 2);
//      }
//      String[] values = str.split("af");
//      num += values.length - 1;
//      System.out.println(num);

        //3、使用replaceAll方法，通过长度进行判断
        String str = "dfdafadergzafgrargsfgsreystgafijoomoafafkpkpojosyiuqhreaw2334sdfsafa";
        String newStr = str.replaceAll("af", "F");
        System.out.println(str.length() - newStr.length());
    }

}

xuchou1990

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java之旅之常用类

常用类字符串：常用字符串属性、方法；包装类与自动装箱，自动拆箱日期类数学类，Math.1、字符串：（一）String str = “hello”; str 指向“hello”常量（static）对象，被放在数据段字符串常量池（除此之外还有线程池、）；这样提升性能，字符串会大量被使用，因此进行预加载；String str2 = “hello”; String str1 = new St
复制链接

扫一扫

专栏目录