java核心API上

String

1.1 概述

当使用字面量定义内容相同的字符串时，java会选择重用对象。如果对其改动（但改动的+号左右不都是字面量），就会新建一个对象，而不是改动原来常量池子里的常量。如果新给一个字符串赋值跟改动后常量相同的字符串，此时虽然相同，但不会重用。java中每一个字符都用2个字节来储存。

String是引用类型，被final修饰，不能被继承。

 1 public class StringDemo1 {
 2 
 3    public static void main(String[] args) {
 4 
 5       String str1 = "helloworld";
 6 
 7       String str2 = "helloworld";
 8 
 9       String str3 = "helloworld";
13       str2 +="!";
14 
15       System.out.println(str2);//helloworld!
16 
17       System.out.println(str3);
18 
19       System.out.println(str1==str3);//ture
20 
21       String str4 = "helloworld!";
22 
23       System.out.println(str4);//helloworld!
24 
25       System.out.println(str2==str4);//false
26 
27       String str5 = "helloworld!";
28 
29       System.out.println(str5==str4);//true
30   }

 

字符串的优化措施带来的问题是，若频繁修改字符串的操作时，对内存的消耗是极大的，甚至可能出现系统崩溃。

　　　　

 1 public class StringDemo3 {
 2 
 3       public static void main(String[] args) {
 4 
 5           String str1 = "123abc";
 6 
 7           String str2 = "123abc";
 8 
 9           String str3 = "123"+"abc";//如何是字面相加，编译器先加起来成为"123abc"
10 
11           String str4 = "1"+23+"abc";
12 
13           String str5 = '1'+23+"abc";
14 
15           String str6 = 1+23+"abc";
16 
17           String str7 = "123";
18 
19           String str8 = str7+"abc";
20 
21          
22           System.out.println(str1==str2);//true
23 
24           System.out.println(str1==str3);//true
25 
26           System.out.println(str1==str4);//true
27 
28           System.out.println(str1==str5);//false
29 
30           System.out.println(str1==str6);//false
31 
32           System.out.println(str1==str8);//false
33 
34       }
35 }

但对字符串改动时，如果都是字面量的相加，编译器会先对其运算。

 

1.2 常用操作

1.2.1 获取。

1)字符串中的包含的字符数，也就是字符串的长度。

　　int length():获取长度。

2) 根据位置获取位置上某个字符。

　　char charAt(int index):

3) 根据字符获取该字符在字符串中位置。

int indexOf(int ch):返回的是ch在字符串中第一次出现的位置。

int indexOf(int ch, int fromIndex) :从fromIndex指定位置开始，获取ch在字符串中出现的位置。

int indexOf(String str):返回的是str在字符串中第一次出现的位置。

int indexOf(String str, int fromIndex) :从fromIndex指定位置开始，获取str在字符串中出现的位置。

int lastIndexOf(int ch) ：

1.2.2 判断。

1) 字符串中是否包含某一个子串。

        boolean contains(str):

        特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。所以，也可以用于对指定判断是否包含。

        if(str.indexOf("aa")!=-1)而且该方法即可以判断，就可以获取出现的位置。

2) 字符中是否有内容。

        boolean isEmpty(): 原理就是判断长度是否为0.

3) 字符串是否是以指定内容开头，否是以指定内容结尾。

　　boolean startsWith(str);

　　boolean endsWith(str);

4) 判断字符串内容是否相同。复写了Object类中的equals方法。

        boolean equals(str);

5) 判断内容是否相同，并忽略大小写。

        boolean equalsIgnoreCase();

1.2.3 转换。

1) 将字符数组转成字符串。

      构造函数：　String(char[])

                       String(char[]，offset，count):将字符数组中的一部分转成字符串。

　　静态方法：

             　　　static String copyValueOf(char[]);

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

　　　　　　　  static String valueOf(char[]):

2) 将字符串转成字符数组。

             char[] toCharArray():

3) 将字节数组转成字符串。

             String(byte[])

             String(byte[],offset,count):将字节数组中的一部分转成字符串。

4) 将字符串转成字节数组。

             byte[]  getBytes():

5) 将基本数据类型转成字符串。

      static String valueOf(int)

      static String valueOf(double)

      //3+"";//String.valueOf(3);

特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

1.2.4 替换

      String replace(oldchar,newchar);

1.2.5 切割

String[] split(regex);

子串。获取字符串中的一部分。

      String substring(begin);

      String substring(begin,end);

 

1.2.6 转换，去除空格，比较。

1)  将字符串转成大写或则小写。

       String toUpperCase();

       String toLowerCase();

2) 将字符串两端的多个空格或空白去除。

　　String trim();//str = str.trim();

3)  对两个字符串进行自然顺序的比较。

      int compareTo(string);

示例1：检查回文

 1  public class StringDemo9 {
 2 
 3       public static void main(String[] args) {
 4 
 5              String str = "上海自来水来自上海";
 6 
 7              for(int i=0;i<str.length()/2;i++){
 8 
 9                     if(str.charAt(i)!=str.charAt(str.length()-1-i)){
18                            System.out.println("不是回文");
19                            return;
20                     }
21              }
22              System.out.println("是回文");
23       }
24 }

 

1.3 字符串缓冲区

是一个容器。用来解决字符串因频繁修改内容带来的系统消耗问题。

1. 长度是可变化的。

2. 可以直接操作多个数据类型。

3. 最终会通过toString方法变成字符串。

CURD      

C：create U:update  R:read   D:delete 

1.3.1 存储

  • StringBuffer  append():将指定数据类型作为参数添加到已有数据的结尾出。
  • StringBuffer  insert(index,数据)。将指定数据插入指定index位置。

1.3.2 删除

  • StringBuffer  delete(start,end)：老规矩，不包含end。
  • StringBuffer  deleteCharAt(index)：删除指定位置字符。

1.3.3 获取

  • char   charAt(int index)
  • int     indexOf(String str);
  • int     lastIndexOf(String str)
  • int     length()
  • String  substring(int start,int end)//注意，这儿返回的不是buffer，而是String.

1.3.4 修改

  • StringBuffer  sb.replace(index,end, string);
  • void               b.setCharAt(int index,char ch);

 

1.3.5 反转

  • StringBuffer reverse();

将缓冲区中指定数据存储到指定字符数组中。

void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

 

三、正则表达式

3.1. 基本正则表达式

3.1.1. 正则表达式简介

所谓正则表达式就是使用一系列预定义的特殊字符来描述一个字符串的格式规则，然后使用该格式规则匹配某个字符串是否符合格式要求。

1)  “.”和"\"

  • "."点儿，在正则表达式中表示任意一个字符。
  • "\"在正则表达式中是转意字符。
  • \d：表示任意一个数字
  • \w：表示任意一个单词字符（只能是 数字，字母，下划线）
  • \s：表示任意一个空白字符(\t \r \n \f \x0B)
  • \D：表示任意一个非数字字符
  • \W：表示任意一个非单词字符
  • \S：表示任意一个非空白字符

2)  "字符集合 []"

  • "[]"用来描述单一字符，方括号内部可以定义这个字符的内容，也可以描述一个范围。例如:
  • [abc]:表示该字符只能是a或者b或者c
  • [123]:表示该字符只能是1或者2或者3
  • [a-zA-Z0-9_] 表示该字符可以是任意字母，数字以及"下划线"。

3) "*"、"+"、"？"

例如：邮箱地址，那么在"@"字符前允许出现若干字符作为用户名。这时候我们就可以使用"\w+"来描述这里至少出现一个单词字符了。

  • "+"：表示内容可以连续出现至少1次以上。
  • "*"：表示内容出现0-若干次 。
  • "?"：表示内容出现0-1次 。

4、{n}、{n,}{n,m}

  • {n}：表示内容必须出现n次
  • {n,m}：表示内容出现n-m次
  • {n,}：表示内容出现至少n次

例如，\d{11} 就表示数字只能出现11位,这样就解决了上述的问题。

3.1.2 分组

  •  () 可以将内容看做一个整体，()中可以使用"|"来表示或关系。例如，(+86|0086) 表示这里可以是+86或者0086。

3.1.3  "^"和"$"

通过在正则表达式的开始添加"^"以及末尾添加"$"来表示一个整体。若不使用它们，那么正则表达式只匹配某个字符串的部分内容是否符合格式规则，但使用它们，则要求字符串必须从头到尾都满足该格式规则。例如，^\w{ 8,10 }$ 表示整体字符串只能出现单词字符8-10个。

3.2 正则相关的API

3.2.1 matches()

  • boolean flag = str.matches(regex)

正则表达式描述的字符串格式规则来匹配当前字符串。需要注意的是，对于matches，不管有没有写^,$都没区别，默认自带。（全部匹配）

3.2.2 split（）

  • String[] split(String regex)

将当前字符串中满足正则表达式的部分作为拆分点，拆分当前字符串，并将拆分出来的每一部分存入字符串数组，并返回。要想把返回的字符数组转换成字符串可通过Arrays.toString()方法实习。

3.2.3 replaceAll

  • String replaceAll(String regex,String str)

将当前字符串中满足正则表达式的部分替换为给定的字符串。注意，这是部分替换，如果替换前面或后面再采用^,$来控制。

例子：

package day02;

/**
 * 使用replaceAll完成和谐用语操作
 * /
public class StringDemo5 {
      public static void main(String[] args) {
             String regex = "(wqnmlgb|sb|cnm|nmd|wc|ch|nc)";
             String message = "wc!wqnmlgb!你这个sb!你怎么这么nc!";
             message = message.replaceAll(regex, "*****");
             System.out.println(message);
      }
}

　　

Object类和包装类

4.1 Object

Object类是java中所有类的顶级父类。若我们定义的一个类没有显式的使用extends继承某个类时，默认就是继承自Object的。

4.1.1 toString()

Object实现了toString()方法，返回的是当前对象的“句柄”。格式为:类的完全限定名@hashcode。因为Object实现的toString()方法不具备什么实际开发意义，所以若我们需要在子类中使用该方法时通常我们会重写它。

public String toString(){

return this;

}

4.1.2 equals()方法

boolean equals():该方法java希望我们重写时返回一个boolean值，表示两个对象间的内容比较是否一致。重写equals方法应遵循几个规则:

  1. 任何对象与null比较都应返回false
  2. 两个对象不属于同一个类时应返回false
  3. 同一个对象equals比较应当恒等为true

那么除此之外，两个对象在比较时，应根据具体的业务需求来自行决定对象的哪些属性相同时对象内容相同。

public boolean equals(Object o){
       if(o == null){
           return false;
       }
       if(o == this){
           return true;
       }
       if(o instanceof Person){
          Person p = (Person)o;
          if(
            this.name.equals(p.name)
            &&
            this.age == p.age
            &&
            this.gender.equals(p.gender)
          ){
              return true;
          }
       }
       return false;
   }

 

equals与 == 的区别：

  • "==":比较的是否为同一个对象，"equals":比较的是两个对象内容是否一样。
  • =="是值比较，对于引用类型变量而言，该变量保存的是对象的地址，所以使用"=="比较时，意思为两个变量的地址是否相等，换句话说就是看两个变量引用的是否为同一个对象
  • equals是内容比较，对于两个引用变量而言，是比较两个变量所引用的对象内容是否相同。举个例子， 就好像一对双胞胎，他们是两个独立的个体，是两个对象。所以那么用"=="比较是 false。但是因为他们“长得一样”，所以equals方法比较是true。
  • 我们也可以变相的理解为:"=="是判断是否为同一个，而"equals"是判断像不像。

4.2 八个基本类型包装类

4.2.1 Number

所有数字类型的包装类都继承自Number，都支持将自身表示的数字转换为不同基本类型的值。但通常只转换自身对应的类型。如果把整形转成double，会制动加0，反过来，去掉小数位。就算是小数转换成double，如果多个小数位后是多个0，一般留一个就行了。

Nuber d = 123.456                    //number是一个抽象类

int a = d.intValue()                  //123

double b = d.doubleValue()    //123.456

4.2.2 包装类

Integer  Character  Double  Float其他都是首字母大写，注意int和char型就可以了

属性：MAX_VALUE，MIN_VALUE。

4.2.3 包装类的作用

1) 基本类型—>字符串：

　　　　基本数据类型+“”；

           String str = Integer.toString(123);

2）字符串-->基本类型：所有数字类型包装类都支持一个静态方法

　　　　int i = Integer.parseInt(str);

　　　　该方法允许将字符串转换为对应的基本类型值，但是前提是该字符串确定描述的是对应的基本类型能表示。

4.2.4 自动拆装箱

（会解释）

如何在基本类型与包装类之间相互转换。

当我们需要将基本类型转换为包装类时，我们可以调用包装类的一个静态方法valueOf()：copytextpop-up

Integer i = Integer.valueOf(1);

如果把1换成1.1，编译错误，这个更字符串和基本数据类型的转换不同。

Double d = Double.valueOf(1.1):

如果把1.1换成1，结果是1.0；

Integer i = Integer.valueOf(1);

Double d = Double.valueOf(1.1):

当我们需要将包装类转换为基本类型时，我们可以使用包装类的方法xxxValue()。copytextpop-up

Integer i = new Integer(1);

int n = i.intValue();

Double d = new Double(1.1);

double dn = d.doubleValue();

但是在java1.5之后可以：

copytextpop-up

  • 1.int i = new Integer(1);//可以自动将包装类转换为基本类型。  自动拆箱
  • Integer in = 1;//可以自动将基本类型转换为包装类。              自动装

事实上JVM不支持该特性，自动拆装箱只是编译器在编译过程中的"预处理"操作

Integer a = 100 => Integer a = Integer.valueOf(100);

Integer b = 200 => Integer b = Integer.valueOf(200);

　　Integer c = a+b => Integer c = Integer.valueOf (a.intValue( ) + b.intValue( ));

　　a和b自动拆箱计算后再装箱变成Integer类型

　　double d = c => double d = c . doubleValue( );自动拆箱

 

日期操作

5.1 Date简介

因为Date（java.util.Date）的设计具有"千年虫"以及"时区"的问题，所以Date中的大部分方法已经不建议使用了，它们都被java.util.Calendar类所取代。

Date now = new Date()；默认创建出来的实例表示当前系统时间Date的toString返回的字符串对非英语地区不是很友好。

   方法：long l =now.getTime():返回毫秒数

　　　　void getTime(long l)：用毫秒设置时间

5.2 SimpleDateFormat

SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。简单的说，SimpleDateFormat就是根据一个特定的日期格式在字符串与Date之间相互转换。

注意：大写的只有M，H。使用E，a时，自动添加汉字。

（1）SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

　　　String str = sdf.format(now);

（2）SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd  HH:mm:ss");

　　　Date date = sdf.parse(str);一般字符串转成其他格式都有Parse。

5.3 Calendar

Calendar是抽象类，其提供了一个工厂方法:Calendar getInstance()。该方法可以根据当前系统所在地区获取一个适当的Calendar的子类实现。

Calendar calendar = Calendar.getInstance();//创建出的Calendar表示当前系统时间。如果直接打印出来，会输出很多分量。

方法：

1)        calendar.set(int field ,int value)

2)        Int a = calendar.get(int field)

设置分量时，可以通过数字或者Calendar的常量来设置

3)        int getActualMaximum(int field)方法用于获取给定时间分量所允许的最大值

4)        calendar.add(Calendar.DAY_OF_YEAR,1).value为负值时，表示减。

5)        Calendar的void setTime(Date date),允许我们为Calendar设置Date对象所表示的时间。

6)        Calendar的 Date getTime(),允许我们获取一个使用Date对象描述的Calendar所表示的时间。

 

集合框架

6.3 LinkedList

6.3.1 特有方法：

  1. addFirst();
  2. addLast();
  3. getFirst();
  4. getLast();

获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

  1. removeFirst();
  2. removeLast();

获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException

 

在JDK1.6出现了替代方法。

  • offerFirst();
  • offerLast();
  • peekFirst();
  • peekLast();

获取元素，但不删除元素。如果集合中没有元素，会返回null。

  • pollFirst();
  • pollLast();

获取元素，但是元素被删除。如果集合中没有元素，会返回null。

 

6.3.2 模拟堆栈或者队列

列：模拟队列，先进先出

package api01.day04;

import java.util.LinkedList;

/**

 * 模拟堆栈或者队列.只是取值是last或者first的区别而已。

 */

public class LinkedListDemo2 {

      public static void main(String[] args) {

             Duilie d = new Duilie();

             d.myAdd("java01");

             d.myAdd("java02");

             d.myAdd("java03");

             d.myAdd("java04");

            

             while(!d.isNull())

             {

                    System.out.println(d.myGet());

             }

      }

}

class Duilie

{

      private LinkedList link;

      Duilie()

      {

             link = new LinkedList();

      }

      public void myAdd(Object obj)

      {

             link.addFirst(obj);

      }

      public Object myGet()

      {

              return link.removeLast();

      }

      public boolean isNull()

      {

             return link.isEmpty();

      }

}

 

posted on 2015-06-07 12:18  ErDaoYa  阅读(187)  评论(0)    收藏  举报

导航