Introduction

Java编程语言的主要特性

  • 面向对象 object-oriented
  • 可移植性,跨平台 portable
  • 支持分布式的网络应用
  • 安全性和健壮性 secure and robust

Java编程语言是个简单的、面向对象的、分布式的、解释性的、健壮的、安全的与系统无关的、可移植的、高性能的、多线程的并且静态的语言——Sun

Java虚拟机

  • 概念
    • Java虚拟机(Java Virtual Machine)在实际的计算机上通过软件模拟来实现;
    • Java虚拟机有自己想象中的硬件。
  • 功能
    • 提供垃圾回收的功能;
    • 提供运行时环境。

JVM

  • .class可以跨平台(操作系统)
  • Java虚拟机每个平台(操作系统)不一样

关于跨平台的概念

  • Java是一次编译到处运行

Java编译为.class文件后,到其他操作系统无需再次编译

  • Java不是一次编写到处运行

C++文件在Windows上编写、编译成.exe文件运行,同样的代码在Linux要再次编译为Linux上可执行文件

Java程序运行模式

  1. 网页中的Applet,依托浏览器运行,目前已经很少使用了;
  2. Web方式(需要依托webserver如tomcat/websphere…);
  3. Application,下文将重点讨论。

Java基础知识

Example

首先来看一个Java应用程序的示例:HelloWorldApp

1
2
3
4
5
6
7
8
9
10
//location:.../src/ch02/HelloWorldApp.java
package ch02;//包的名字,注意一定要和目录严格匹配
//注意如何定义一个类,每个.java文件只能定义一个public类,类名字必须和文件名完全符合
public class HelloWorldApp{
//任何一个Application程序必须要有一个public static void main(String[] args)方法
//但不是所有的类都需要main方法
public static void main(String[] args){
System.out.println("Hello World!");
}
}

关于包package

  • 每个包对应了源程序的一个目录,每个包可以有子包(子目录);
  • JDK的Java类库中的几个重要包:java.lang, java.io, java.awt, java.net, java.util;
  • 包不同层级之间用 . 分割,正如目录用 / 分割;
  • 一个包下包含了若干类文件或者子包
    • 包 ch02 对应了 ch02/;
    • 包 ch02.sub01 对应了 ch02/sub01/。

关于Java的源文件

  • 初学者可以认为一个源文件(.java)对应一个类的定义(实际上这种说法并不准确,初学者可以这样认为);
  • .java文件经过编译后生成一个.class文件;
  • Java虚拟机解释.class文件执行程序(java不能直接生成.exe文件)。

关于main方法

  • 每个能够以Java Application模式运行的类中必须有一个main方法;
  • public static void main(String[] args)或static public void main(String[] args)。

Java最基本语法

  • {} 程序段

  • 每行程序以分号;结束

  • // 单行注释

  • /* 。。。*/ 多行注释

  • System.out.println(); 输出并换行;

  • System.out.print(); 输出不换行;

  • Java对大小写非常敏感!

    包名、类名、方法名、变量名均大小写敏感!

字符界面的输入与输出

  • java.io包

  • System.in.read()

  • System.out.print()/println()

  • 程序:

    • ch02.AppCharInOut

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      package ch02;

      import java.io.*;

      /**
      * 例子2-3
      *
      * 本例子演示了如何从控制台读入一个字符,并输出。
      *
      * @author Administrator
      *
      */
      public class AppCharInOut {
      public static void main(String[] args) {
      char c = ' ';
      System.out.print("Please input a char: ");
      try {
      c = (char) System.in.read();
      } catch (IOException e) {
      }
      System.out.println("You have entered: " + c);
      }
      }
    • ch02.AppLineInOut

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      package ch02;

      import java.io.*;

      /**
      * 本例子演示了如何从控制台读入一个行字符,并输出。
      *
      * @author Administrator
      *
      */
      public class AppLineInOut {
      public static void main(String[] args) {
      String s = "";
      System.out.print("Please input a line: ");
      try {
      BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
      s = in.readLine();
      } catch (IOException e) {
      }
      System.out.println("You have entered: " + s);
      }
      }
    • ch02.AppNumInOut

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      package ch02;

      //导入输入输出包
      import java.io.*;

      /**
      * 例子2-5 本例子演示了如何从控制台读入一个数字(浮点或者整数)并输出
      *
      * @author Administrator
      *
      */
      public class AppNumInOut {
      public static void main(String[] args) {
      String s = "";
      int n = 0;
      double d = 0;
      try {
      BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
      System.out.print("Please input an int: ");
      s = in.readLine();
      n = Integer.parseInt(s);
      System.out.print("Please input a double: ");
      s = in.readLine();
      d = Double.parseDouble(s);
      //异常的处理,初学者可以忽略这部分
      } catch (IOException e) {
      }
      System.out.println("You have entered: " + n + " and " + d);
      }
      }

查看JDK源码

  • 以Eclipse oxygen为例
  • 操作系统Windows7 64位
  • 其他操作系统及软件版本操作类似

鼠标点击对应变量名

鼠标点击对应变量名

或者ctrl鼠标点击方法名

ctrl鼠标点击方法名

Java数据类型

Java数据类型划分

Java中的数据类型分为两大类

  • 一类是基本数据类型(primitive types);
  • 另一类是引用类型(reference types);

后者相当于对象

={={={(byte,short,int,long)(float,double)(char)(boolean)={(class)(interface)数据类型=\begin{cases} 基本数据类型=\begin{cases} 数值型=\begin{cases} 整数类型(byte,short,int,long)\\ 浮点类型(float,double) \end{cases}\\ 字符型(char)\\ 布尔型(boolean) \end{cases}\\ 引用数据类型=\begin{cases} 类(class)\\ 接口(interface)\\ 数组 \end{cases} \end{cases}

Java基本数据类型

  • Java中定义了四类/八种基本数据类型
    • 逻辑型——boolean
    • 文本型——char
    • 整数型——byte,short,int,long
    • 浮点数型——float,double

逻辑型

  • boolean类型适合于逻辑运算,一般用于程序流程控制;

  • boolean类型数据只允许取值true或false,不可以0或非0的整数替代true和false

  • 例如

    1
    2
    3
    4
    5
    boolean b=false;
    if(b==true)
    {
    //do something
    }

字符类型

  • char型数据用来表示通常意义上“字符”;

  • 字符常量是用单引号括起来的单个字符

    char c = ‘A’;

  • Java字符采用Unicode编码,每个字符占两个字节,因而可用十六进制编码形式表示

    char c1 = ‘\u0061’;

  • Java语言中还允许使用转义字符’'来将其后的字符转变为其他的含义

    char c2 = ‘\r’;

常用的转义字符

常用的转义字符

整数类型

  • Java各整数类型有固定的表数范围和字段长度,而不受具体操作系统的影响,以保证Java程序的可移植性

    • 类型 占用存储空间(字节) 表数范围
      byte 1 -128~127
      short 2 -215~215-1
      int 4 -231~231-1
      long 8 -263~263-1
  • Java语言整形常量的三种表示形式(ch03.HexOctInt):

    • 十进制整数:如12,-134,0;
    • 八进制整数:要求以0开头,如012;
    • 十六进制数:要求以0x或0X开头,如0x12。
  • Java语言的整形常量默认为int型,如:

    int i=3;

  • 声明long型常量可以后加’l’或’L’,如:

    long l=3L;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//ch03.HexOctInt
package ch03;

public class HexOctInt {

public HexOctInt() {
// TODO Auto-generated constructor stub
}

public static void main(String[] args) {
int i = 10;
int j = 010;//鍏繘鍒�
int k = 0x10;//鍗佸叚杩涘埗
System.out.println("10=" + i);
System.out.println("010=" + j);
System.out.println("0x10=" + k);
}
}

浮点型

  • Java浮点类型有固定的表数范围和字段长度

    类型 占用存储空间(字节) 表述范围
    float 4 -3.403E38~3.403E38
    double 8 -1.798E308~1.798E308
  • Java浮点类型常量有两种表示形式

    • 十进制数形式,必须含有小数点,例如:

      3.14,314.0,。314

    • 科学计数法形式,如:

      3.14e2,3.14E2,314E2

  • Java浮点型常量默认为double型,如要声明一个常量为float型,则需在数字后面加f或F,如:

    double d=3.14;

    float f=3.14f;

基本数据类型变量声明和赋值

例子见如下代码 ch03.DeclareAssign

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//ch03.DeclareAssign
package ch03;

public class DeclareAssign
{
public static void main (String args []) {
boolean b = true;
int x, y=8;
float f = 4.5f;
double d = 3.1415;
char c;
c ='\u0031';
x = 12;
System.out.println("b=" + b);
System.out.println("x=" + x);
System.out.println("y=" + y);
System.out.println("f=" + f);
System.out.println("d=" + d);
System.out.println("c=" + c);
}
}

Java中的关键字

Java中的关键字

标识符

  • 任何一个变量、常量、方法、对象和类都需要有名字,这些名字就是标识符。标识符可以由编程者自由指定,但是需要遵循一定的语法规定;
  • 标识符要满足如下的规定:
    • 首字母只能是a-z,A-Z,$或者_;
    • 其余字母只能是a-z,A-Z,$,_或者数字。
  • 在实际应用标识符时,应该使标识符能一定程度上反映它所表示的变量、常量、对象、或类的意义,这样程序的可读性会更好;
  • 同时,应注意Java时大小写敏感的语言

标识符实例

运算符与表达式

运算符

算术运算符

算术运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//ch03.ArithmaticOp
package ch03;

public class ArithmaticOp{
public static void main( String args[] ){
int a=5+4; //a=9
int b=9*2; //b=18
int c=18/4; //c=4
int d=18-4; //d=14
int e=-d; //e=-14
int f=-14%4; //f=-2
double g=18.4;
double h=g%4; //h=2.4
int i=3;
int j=i++; //i=4,j=3
int k=++i; //i=5,k=5
System.out.println("a = "+a);
System.out.println("b = "+b);
System.out.println("c = "+c);
System.out.println("d = "+d);
System.out.println("e = "+e);
System.out.println("f = "+f);
System.out.println("g = "+g);
System.out.println("h = "+h);
System.out.println("i = "+i);
System.out.println("j = "+j);
System.out.println("k = "+k);
}
}

逻辑运算符

逻辑运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//ch03.LogicOperator
package ch03;

public class LogicOperator{
public static void main( String args[] ){

System.out.println("true&&false ="+(true&&false) );
System.out.println("true||false ="+(true||false) );
System.out.println("!true =" +(!true));
System.out.println("true^false =" +(true^false));
System.out.println("true&false ="+(true&false) );
System.out.println("true|false ="+(true|false) );
}
}

逻辑运算符

位运算符

位运算符

移位运算符

移位运算符

移位运算符性质

  • 使用数据类型:byte、short、char、int、long,对低于int型的操作数将先自动转换为int型再移位;
  • 对于int型整数移位a>>b,系统先将b对32取模,得到的结果才是真正移位的位数;
  • 同样的,对于long型整数移位a>>b,则是先将b对64取模。

移位运算符应用举例

Example

赋值运算符

赋值运算符=

  • “=” 两侧的数据类型不一致时,可以使用默认类型转换或强制类型转换(casting)原则进行处理

    1
    2
    long l=100;
    int i=(int)l;
  • Exception:可以将整型常量直接赋值给byte,short,char等类型变量,而不需要进行强制类型转换,只要不超出其表数范围

    1
    2
    byte b=12;   //legal
    byte b=4096; //illegal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
//ch03.AssignOpertor
/**
*
*/
package ch03;

public class AssignOpertor {

/**
*
*/
public AssignOpertor() {
// TODO Auto-generated constructor stub
}

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
double d=65;
//float f1=d;//Wrong
float f2=(float)d;//Right
//int i1=f2;//Wrong
int i2=(int)f2;//Right
//char c1=i2;//Wrong
char c2=(char)i2;//Right
//byte b1=c2;//Wrong
byte b2=(byte)c2;//Right
//byte b3=128;//Wrong
byte b4=65;//Right
System.out.println("i2="+i2);
System.out.println("c2="+c2);
System.out.println("b2="+b2);

}

}

扩展赋值运算符

扩展赋值运算符

位和位移运算的实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//ch03.BitOpertor
package ch03;

public class BitOperator {

public static void main(String args[]) {
int FLAG1 = 1; // (0x0001)
int FLAG2 = 2; // (0x0010)
int FLAG3 = 7; // (0x0111)
System.out.println("0x0001|0x0010=" + (FLAG1 | FLAG2));
System.out.println("0x0001&0x0111=" + (FLAG1 & FLAG3));
System.out.println("0x0001^0x0111=" + (FLAG1 ^ FLAG3));
System.out.println("0x0001&0x0111=" + (~FLAG1));
System.out.println("2<<1=" + (2 << 1));
System.out.println("2>>1=" + (2 >> 1));
System.out.println("2>>1=" + ((-2) >> 1));
System.out.println("2>>>1=" + ((-2) >>> 1));
}
}

表达式

  • 表达式是符合一定语法规则的运算符和操作数的序列

    Example

  • 表达式的类型和值

    • 对表达式中操作数进行运算得到的结果称为表达式的值;
    • 表达式的值的数据类型即为表达式的类型。
  • 表达式的运算顺序

    • 首先应按照运算符的优先级从高到低的顺序进行;
    • 优先级相同的运算符按照事先约定的结合方向进行。

表达式中的类型转换

  • 当有不同种类的混合运算时:int→long→float→double;
  • 所有的byte,short,char等转为int;
  • 例如
1
2
3
double d=1;
System.out.println(2*d);
//输出为2.0而不是2

运算符优先级与结核性

运算符优先级与结合性

流程控制语句

结构化程序设计的三种基本流程

  • 顺序、分支、循环

三种基本流程

简单语句

  • 最简单的语句是方法调用语句及赋值语句,是在方法调用或赋值表达式后加一个分号(;)
1
2
3
System.out.println("Hello World");
a=3+x;
b=a>0?a:-a;

分支语句——if

IF

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//ch03.LeapYear
/**
*
*/
package ch03;

public class LeapYear {

/**
*
*/
public LeapYear() {
// TODO Auto-generated constructor stub
}

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int year = 2003;
if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
System.out.println(year + " is a leap year.");
} else {
System.out.println(year + " is not a leap year.");
}
}

}

分支语句——switch

SWITCH

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//ch03.GradeLevel.java
package ch03;

public class GradeLevel{
public static void main( String args[ ] ){

char grade='C'; //normal use
switch( grade ){
case 'A' :
System.out.println(grade+" is 85~100");
break;
case 'B' :
System.out.println(grade+" is 70~84");
break;
case 'C' :
System.out.println(grade+" is 60~69");
break;
case 'D' :
System.out.println(grade+" is <60");
break;
default :
System.out.println("input error");
}
}
}

循环语句

CYCLE

  • 循环语句功能
    • 在循环条件满足的情况下,反复执行特定代码。
  • 循环语句的四个组成部分
    • 初始化部分(init_statement);
    • 循环条件部分(test_exp);
    • 循环体部分(body_statement);
    • 迭代部分(alter_statement)。
  • 循环语句分类
    • for循环;
    • while循环
    • do/while循环。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//ch03.Sum100
package ch03;

public class Sum100 {
public static void main(String args[]) {
int sum, n;

System.out.println("\n**** for statement ****");
sum = 0;
for (int i = 1; i <= 100; i++) {
sum = sum+i;
}
System.out.println("sum is " + sum);

System.out.println("\n**** while statement ****");
sum = 0;
n = 100;
while (n > 0) {
sum += n;
n--;
}
System.out.println("sum is " + sum);

System.out.println("\n**** do_while statement ****");
sum = 0;
n = 0;
do {
sum += n;
n++;
} while (n <= 100);
System.out.println("sum is " + sum);
}
}

特殊流程控制语句

BREAK

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//ch03.BreakDemo
/**
*
*/
package ch03;

public class BreakDemo {

/**
* @param args
*/
public static void main(String args[]) {
for (int i = 0; i < 10; i++) {
if (i == 3)
break;
System.out.println(" i =" + i);
}
System.out.println("Game Over!");
}

}

CONTINUE

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//ch03.ContinueDemo
/**
*
*/
package ch03;

public class ContinueDemo {

/**
* @param args
*/
public static void main(String args[]) {
round1:for (int i = 0; i < 10; i++) {
round2:for (int j = 0; j < 10; j++) {
if (j %2!=0)
continue round2;
if (i %2==0)
continue round1;
System.out.println(" i =" + i+"\t j =" + j);
}
}
System.out.println("Game Over!");
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//ch03.BreakContinue
package ch03;

public class BreakContinue {

public BreakContinue() {
// TODO Auto-generated constructor stub
}

public static void main(String[] args) {
label1: for (int i = 0; i < 5; i++) {
label2: for (int j = 0; j < 5; j++) {
if(j==3){
continue label2;
}
if(i==3){
break label1;
}
System.out.println("i=" + i + " j=" + j);
}
}

}

}

数组

数组概述

  • 数组是多个相同类型数据的组合,实现对这些数据的统一管理;
  • 数组属于引用类型,数组型数据是对象(object),数组中的每个元素相当于该对象的成员变量;
  • 数组中的元素可以是任何数据类型,包括基本类型和引用类型。

一维数组声明

  • 一维数组的声明方式

    1
    2
    3
    4
    5
    type var[] or type[] var
    //For example
    int a[];
    int[] a1;
    double b[];
  • Java语言中声明数组时不能指定其长度(数组中元素的个数)

    1
    int a[5]; //illegal
  • 但是可以在需要初始化的时候声明长度

    1
    int[] a=new int[5];
  • Java数组长度可以是变量(不同于C)

    1
    2
    int len=4;
    int[] a=new int[len];
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//ch03.ArrayDemo
package ch03;

/**
* 涓�缁存暟缁勭殑澹版槑鍜屽垵濮嬪寲
* @author Administrator
*
*/
public class ArrayDemo {
public static void main( String args[ ] ){
int[] a;
a = new int[3];
a[0] = 3;
a[1] = 9;
a[2] = 8;

int[] b= new int[3];
b[0] = 3;
b[1] = 9;
b[2] = 8;

int[] c= {1,2,3};
//The following is illegal
//int[] d=new int[3];
//d= {1,2,3};

int f[]= {1,2,3};
System.out.println(f instanceof Object);

}
}

数组元素的默认初始化

  • 数组是引用类型,它的元素相当于类的成员变量,因此数组一经分配空间,其中的每个元素也被按照成员变量同样的方式被隐式初始化
1
2
3
4
5
6
public class Test{
public static void main(String[] args){
int a[]=new int[5];
System.out.println(a[3]);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//ch03.Fibonacci
package ch03;

public class Fibonacci {
public static void main(String args[]) {
int i;
int f[] = new int[10];
f[0] = f[1] = 1;
for (i = 2; i < f.length; i++) {
f[i] = f[i - 1] + f[i - 2];
}
for (i = 1; i <= f.length; i++) {
System.out.println("F[" + i + "]= " + f[i - 1]);
}
}
}

数组元素的引用

  • 定义并用运算符 new 为之分配空间后,才可以引用数组中的每个元素;

  • 数组元素的引用方式:arrayName[index]

    • index为数组元素下标,可以是整型常量或整型表达式

      如a[3], b[i], c[6*i];

    • 数组元素下标从0开始;长度为n的数组合法下标取值范围:0~n-1;

  • 每个数组都有一个属性 length 指明它的长度

    例如:a.length 指明数组 a 的长度(元素个数)。

多维数组

1
2
//二维数组举例
int a[][]={{1,2},{3,4,0,9},{5,6,7}};
i\j j=0 j=1 j=2 j=3
i=0 1 2
i=1 3 4 0 9
i=2 5 6 7
  • Java中多维数组被做为数组的数组处理;

  • Java中多维数组的声明和初始化应按从高维到低维的顺序进行

    1
    2
    3
    4
    5
    6
    //legal
    int t[][]=new int[4][];
    t[0]=new int[5];
    t[1]=new int[5];
    //illegal
    int t1[][]=new int[][4];
  • Java中多维数组不必须是规则矩阵形式

    1
    2
    3
    4
    5
    6
    7
    int [][] tt=new int[4][];
    tt[0]=new int[2];
    tt[1]=new int[4];
    tt[2]=new int[6];
    tt[3]=new int[8];

    int tt[][]=new int[4][5];

多维数组初始化

静态初始化

1
2
int intArray[][]={{1,2},{2,3},{3,4,5}};//legal
int intArray[3][2]={{1,2},{2,3},{4,5}};//illegal

动态初始化

1
2
3
4
5
int a[][]=new int[4][5];
int b[][]=new int[3][];
b[0]=new int[2];
b[1]=new int[3];
b[2]=new int[5];

复制数组

COPY ARRAY

关于String和char初步认知

Java中字符(char)和字符串(String)的区别

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//ch03.CharAndString
/**
*
*/
package ch03;

public class CharAndString {

public static void main(String[] args) {
char c='a';
char c2=(char)256;
String s1="abc";
String s2=String.valueOf(c);
System.out.println("c="+c);
System.out.println("c2="+c2);
System.out.println("s1="+s1);
System.out.println("s2="+s2);

}

}
  • char是基本数据类型,可以保存一个字符,用’ ';
  • 可以把一个整数转换为char;
  • String是一个类,可以保存0个或者更多char,用" ";
  • String类中提供把char转换为String的方法。

Java中的字符

  • "+"可用于对字符串进行连接操作

    1
    String s="hello, "+"world!";
  • "+"两侧操作数中只要有一个是字符串(String)类型,系统会自动将另一个操作数转换为字符串

    1
    2
    3
    4
    int i=300+5;
    String s="hello, "+i+"号";
    System.out.println(s);
    //输出:hello, 305号
  • 体会"+"的不同结果

    1
    2
    3
    4
    String s5="1"+'1';
    char c2='1'+'1';
    System.out.println(s5+","+c2);
    //输出:11,b

char[] String int 之间的转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//ch03.CharArrayStringInt
/**
*
*/
package ch03;

public class CharArrayStringInt {

public CharArrayStringInt() {
// TODO Auto-generated constructor stub
}

public static void main(String[] args) {
String s1 = "abc";
// String to char[]
char[] charArray = s1.toCharArray();
// char[] to String
String s2 = new String(charArray);
// get the length of String
int len = s1.length();
int num=123;
// int to String
String s3=String.valueOf(num);
// String to int
int num2=Integer.valueOf(s3);
}

}

字符串的比较

  • 判断s1,s2是否相等

    1
    2
    3
    s1.equals(s2);
    or
    s1.equalsIgnoreCse(s2);
  • 比较两个字符串大小

    1
    2
    3
    4
    s1.compareTo(s2);
    相等 返回0;
    大于 返回正数,第一位不同的字符相差的ASCII值;
    小于 返回负数,第一位不同的字符相差的ASCII值;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//ch03.StringCompare

package ch03;

public class StringCompare {

public StringCompare() {
// TODO Auto-generated constructor stub
}

public static void main(String[] args) {
String s1="";
String s2="123";
for(int i=0;i<4;i++) {
s1=s1 + i;
} System.out.println("s1.equals(s2):"+s1.equals(s2));
System.out.println("s1 == s2 :"+(s1==s2));
System.out.println("abc.equals(ABc) :"+"abc".equals("ABc"));
System.out.println("abc.equals(ABc) :"+"abc".equalsIgnoreCase( "ABc"));
System.out.println("abc.compareTo(aaa) :"+"azc".compareTo("aaa"));
System.out.println("abc.compareTo(abc) :"+"abc".compareTo("abc"));
System.out.println("abc.compareTo(abd) :"+"abc".compareTo("abz"));
}

}

String其他常见操作

String其他常见操作

错误程序例子

Wrong

测试代码及输出结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package Test;

public class Test{
public static void main(String[] args) {
int i=300+5;
String s="hello"+i+"号";
System.out.println(s);

String s5="1"+'1';
char c2='1'+'1';
System.out.println(s5+","+c2);

System.out.println(5+7);
System.out.println(1234567890+1234567890);
System.out.println(1234567890l+1234567890);

System.out.println("abc.compareTo(aaa) :"+"azc".compareTo("aaa"));
System.out.println("abc.compareTo(abc) :"+"abc".compareTo("abc"));
System.out.println("abc.compareTo(abd) :"+"abc".compareTo("abz"));
}
}

结果

文章源码

文章源码 备用仓库