JAVA语言基础知识点总结及应注意问题.doc

JAVA语言基础知识点总结和应注意问题——（字符、数组等基本语法）

String
String字符串赋值
String s1=”abc”+”123”;(用+号连接时正确的)
String s2=new String(s1);
String s3=new String(“abc”);
String s4=new String();//创建空串
int k=s1.length(); 表示一个字符串的长度

——String类构造函数：

构造函数
详细解释
实例
public Sring()
该构造函数用于创建一个空的字符串常量。
Eg：String s=new String();
public String(String value)
该构造函数用于根据一个已经存在的字符串函数常量来创建一个新的字符串常量，该字符串的内容和已经存在的字符串常量一致。
Eg: String s1=new String(“abc”);
String s2=new String(s1);
String(byte[] bytes, String charsetName);
构造一个新的String，方法是使用指定的字符集解码指定字节数组。
——一般在浏览器上传非英语字符时使用，以免出现乱码。
Eg：String s=new String(“字符的秘密”);
String s5=new String(s.getBytes(“GBK”), “Unicode/UTF-8”);//两者必须相对应
public String(char value[])
该构造函数用于根据一个已经存在的字符数组来创建一个新的字符串常量。
Eg：char chars[]={‘a’, ‘b’, ‘c’};
String s3=new String(chars);
public String(StringBuffer buffer)
该构造函数用于根据一个已经存在的StringBuffer对象来创建一个新的字符串常量。
Eg：StringBuffer sb=new StringBuffer(“abc”);
sb.append(“字符串”);
String sb1=new String(sb);

——关于构造函数验证程序如下：

public class chapter03_1 {
public static void main(String args[])
{
//常见字符串赋值方法
String s1="abc";
String s2="abc"+"def";
String s3=s1+s2;
String s4=s1+"abc";
//使用public String(String value)构造函数
String s5=new String("abcdef");
String s6=new String(s5);
//使用public String()构造函数
String s7=new String("");

//使用 String(byte[] bytes, String charsetName)构造函数
//String s8= new String(s7.getBytes("GBK"), "Unicode");
//使用public String(char value[])构造函数
char[] chars={'a','b','c'};
String s9=new String(chars);

//使用public String(StringBuffer buffer)构造函数
StringBuffer s11=new StringBuffer("abc");
s11.append("def");
String s12=new String(s11);
//打印输出结构
System.out.println("s1="+s1);
System.out.println("s2="+s2);
System.out.println("s3="+s3);
System.out.println("s4="+s4);
System.out.println("s5="+s5);
System.out.println("s6="+s6);
System.out.println("s7="+s7);
System.out.println("s9="+s9);
System.out.println("s11="+s11);
System.out.println("s12="+s12);

}
}

——结果如下：

s1=abc
s2=abcdef
s3=abcabcdef
s4=abcabc
s5=abcdef
s6=abcdef
s7=
s9=abc
s11=abcdef
s12=abcdef

——String类对象的常用操作及方法
（在java中，String类包含有50多个方法来实现字符串的各种操作）

※ 在任何字符串中所引的位置均从0开始算起，索引位置在字符串中是不变的，
不会因从前数或者从后搜索而改变。

函数
详细解释
char charAt(int index)
返回指定索引处的char值
int compareTo(String anotherStr)
按字典顺序比较两个字符串
int compareToIngnoreCase(String str)
不考虑大小写，按字典顺序比较两个字符串
Eg：pareTo(s1); 批注：返回的类型为int型，返回的是（s-s1）ASCII码的相减值，s-s1顺序不能颠倒；若返回值为0，则表示两字符串相等。
String concat(String str)
将制定字符串联到此字符串的结尾。等同于“+”
boolean endsWith(String suffix)
测试此字符串是否以指定的后缀结束
boolean startsWith(String prefix)
测试此字符串是否以指定的前缀开始
boolean equals(Object anObject)
比较此字符串与制定的对象
boolean equalsIgnoreCase(String anotherString)
将此String与另一个String进行比较，不考虑大小写
Eg：s.equals(s1); 批注：效果同compareTo一致但是返回类型不一致
int hashCode()
返回此字符串的哈希码
int indexOf(String str)
返回第一次出现的指定的子字符串在此字符串中的索引位置
int indexOf(String str, int fromIndex)
从指定的索引处开始进行向后搜索，返回第一次出现的指定子字符串在此字符串中的索引
int lastIndexOf(String str)
返回最后一次出现的指定字符串在此字符串中的索引
int lastIndexOf(String str, int fromIndex)
从指定的索引位置开始进行向后搜索，返回最后一次出席那的制定字符串在此字符串中的索引
int length()
返回字符串的长度
String replaceFirst(String regex, String replacement)
该方法用字符串replacement的内容替换当前字符串中遇到的第一个和字符串regex相一致的子串，并将产生的新字符串返回
String replaceAll(String regex,String replacement)
该方法用字符串replacement的内容替换当前字符串中遇到的所有和字符串regex相一致的子串，并将产生的新字符串返回
String[] split(String regex)
根据给定的字符串来拆分此字符串，得到一个字符串数组
String substring(int beginIndex)
String substring(int beginIndex,int endIndex)
返回一个新的字符串，它是此字符串的一个子字符串
String toLowerCase()
把字符串转换为小写
String toUpperCase()
把字符串转换为大写
String trim()
去掉字符串两端的空格
Static String valueOf(xxx b)
把其他类型变量转换成字符串

——关于String 类对象的常用操作及方法验证代码如下：
public class Chapter3 {

public static void main(String[] args) {

String s1=" abcwD我们的c秘密 我们的秘密 ";
String s2="abcWd我们的秘密";
// String charAt(int index)
System.out.println("返回s1字符串指定的索引处的char值是："+s1.charAt(0));

//int compareTo/compareToIgnoreCase(String anotherStr)
//使用CompareTo函数返回两字符串第一个不相同字符ASCII码的差值
System.out.println("s1和s2用compareTo比较结果是："+pareTo(s2));
System.out.println("s1和s2用compareToIngnoreCase不考虑字母大小比较结果是："+pareToIgnoreCase(s2));

//String concat(String anotherStr)
System.out.println("s1字符串与s2字符串连接的新字符串是："+s1.concat(s2));

//boolean startsWith/endsWith(String fix)
System.out.println("s1字符串是否以指定的字符串开始，返回布尔值：："+s1.startsWith("abc"));
System.out.println("s1字符串是否以指定的字符串结束，返回布尔值：："+s1.endsWith("秘"));

//boolean equals/equalsIgnoreCase(String anotherStr)
System.out.println("s1和s2用equals比较两字符串是否相等，返回布尔值："+s1.equals(s2));
System.out.println("s1和s2用equalsIgnoreCase不考虑大小写比较两字符串是否相等，返回布尔值："+s1.equalsIgnoreCase(s2));

// int hasdCode()
System.out.println("返回s1字符串的哈希码，返回值是数值型："+s1.hashCode());

//int indexOf(String str)
//int inedexOf(String str, int fromIndex)
//在任何字符串中所引的位置均从0开始算起，索引位置在字符串中是不变的，不会因从前数或者从后数而改变
System.out.println("返回第一次出现的指定子字符在此字符串中的索引位置："+s1.indexOf("c"));
//此题目中从指定的索引位置开始数，但是该字符的索引位置还是从头开始的
System.out.println("返回从指定的索引位置开始，返回第一次出现的指定子字符在此字符串中的索引位置："+s1.indexOf("c",3));

//int lastIndexOf(String str)
//int lastIndexof(String str,int fromIndex)
//只是开始索引的方向变了，每个字符在此字符串中的索引位置是固定的
System.out.println("返回最后一次出现的制定字符串在此字符串中的索引位置: "+s1.lastIndexOf("c"));
System.out.println("返回从指定的索引位置开始向后搜索，返回第一次出现的指定字符在此字符串中的索引位置："+s1.lastIndexOf("c",7));

//int length()
System.out.println("返回s1字符串的长度： "+s1.length());

//String replaceFirst(String regex. String replacement)
//String replaceAll(String regex, String replacement)
System.out.println("使用replaceFirst方法用子字符串替代当前字符串中遇到第一个指定的子字符串： "+s1.replaceFirst("我","你"));
System.out.println("使用replaceAll方法用子字符串替代当前字符串中遇到所有指定的子
字符串： "+s1.replaceAll("我","你"));

//String[] split(String regex)
System.out.println("使用split方法用指定的子字符串来拆分此字符串，得到一个字符串数
组： "+s1.split("的")[0]+" *** "+s1.split("的")[1]+" *** "+s1.split("的")[2]);
//指出开始的索引位置，求得子字符串

//String substring(int beginIndex)
//String substring(int beginIndex,int endIndex)
System.out.println("返回一个新的字符串，它是此字符串的一个子字符窜：
"+s1.substring(2));
System.out.println("返回一个新的字符串，它是此字符串的一个子字符窜：
"+s1.substring(2,5));

//String toLowerCase/toUpperCase()
System.out.println("把字符串转换为小写： "+s1.toLowerCase());
System.out.println("把字符串转换为大写： "+s1.toUpperCase());

//String trim()
System.out.println("去掉字符串两端的空格： "+"***"+s1.trim()+"***");

//static String valueOf(xxx b)
//System.out.println("把其他类型转换为字符串型： "+valueOf(a)); ???有问题???

}
}

——结果如下：
返回s1字符串指定的索引处的char值是：
s1和s2用compareTo比较结果是：-65
s1和s2用compareToIngnoreCase不考虑字母大小比较结果是：-65
s1字符串与s2字符串连接的新字符串是： abcwD我们的c秘密 我们的秘密 abcWd我们的秘密
s1字符串是否以指定的字符串开始，返回布尔值：：false
s1字符串是否以指定的字符串结束，返回布尔值：：false
s1和s2用equals比较两字符串是否相等，返回布尔值：false
s1和s2用equalsIgnoreCase不考虑大小写比较两字符串是否相等，返回布尔值：false
返回s1字符串的哈希码，返回值是数值型：282750190
返回第一次出现的指定子字符在此字符串中的索引位置：3
返回从指定的索引位置开始，返回第一次出现的指定子字符在此字符串中的索引位置：3
返回最后一次出现的制定字符串在此字符串中的索引位置: 9
返回从指定的索引位置开始向后搜索，返回第一次出现的指定字符在此字符串中的索引位置：3
返回s1字符串的长度： 20
使用replaceFirst方法用子字符串替代当前字符串中遇到第一个指定的子字符串： abcwD你们的c秘密 我们的秘密
使用replaceAll方法用子字符串替代当前字符串中遇到所有指定的子字符串： abcwD你们的c秘密 你们的秘密
使用split方法用指定的子字符串来拆分此字符串，得到一个字符串数组： abcwD我们 *** c秘密 我们 *** 秘密
返回一个新的字符串，它是此字符串的一个子字符窜：bcwD我们的c秘密 我们的秘密
返回一个新的字符串，它是此字符串的一个子字符窜：bcw
把字符串转换为小写： abcwd我们的c秘密 我们的秘密
把字符串转换为大写： ABCWD我们的C秘密 我们的秘密
去掉字符串两端的空格： ***abcwD我们的c秘密 我们的秘密***

StringBuffer
——StringBuffer类也是java.lang.Object的子类。与String类不同，StringBuffer类是一个在操作中可以更改其内容的字符串类。

——StringBuffer类构造函数：

构造函数
详细解释
实例
public StringBuffer()
创建一个空字符串缓冲区，默认初始长度为16个字符。
Eg：StringBuffer s1=new StringBuffer();
public StringBuffer(int length)
用length指定的初始长度创建一个空字符串缓冲区。
Eg: StringBuffer s2=new StringBuffer(16);
StringBuffer s3=new StringBuffer(s2.length());
public StringBuffer(String str)
用指定的字符串str穿件一个字符串缓冲区，其长度为str的长度再加上16个字符。
Eg： StringBuffer s3=new StringBuffer("abcdef");
StringBuffer s4=new StringBuffer(s3);

——关于构造函数验证程序如下：

public class example4 {

public static void main(String[] args) {
StringBuffer s1=new StringBuffer();
StringBuffer s2=new StringBuffer(16);
StringBuffer s3=new StringBuffer("abcdef");
StringBuffer s4=new StringBuffer(s3);
System.out.println("s1="+s1);
System.out.println("s2="+s2);
System.out.println("s3="+s3);
System.out.println("s4="+s4);
System.out.println("s1的长度是： "+s1.length());
System.out.println("s2的长度是： "+s2.length());
System.out.println("s3的长度是： "+s3.length());
System.out.println("s4的长度是： "+s4.length());
}
}

——结果如下：

s1=
s2=
s3=abcdef
s4=abcdef
s1的长度是： 0
s2的长度是： 0
s3的长度是： 6
s4的长度是： 6

——StringBuffer类对象的常用操作及方法

方法摘要
 StringBuffer
append(boolean b)
          将 boolean 参数的字符串表示形式追加到序列。
 StringBuffer
append(char c)
          将 char 参数的字符串表示形式追加到此序列。
 StringBuffer
append(char[] str)
          将 char 数组参数的字符串表示形式追加到此序列。
 StringBuffer
append(char[] str, int offset, int len)
          将 char 数组参数的子数组的字符串表示形式追加到此序列。
 StringBuffer
append(CharSequence s)
          将指定的 CharSequence 追加到该序列。
 StringBuffer
append(CharSequence s, int start, int end)
          将指定 CharSequence 的子序列追加到此序列。
 StringBuffer
append(double d)
          将 double 参数的字符串表示形式追加到此序列。
 StringBuffer
append(float f)
          将 float 参数的字符串表示形式追加到此序列。
 StringBuffer
append(int i)
          将 int 参数的字符串表示形式追加到此序列。
 StringBuffer
append(long lng)
          将 long 参数的字符串表示形式追加到此序列。
 StringBuffer
append(Object obj)
          追加 Object 参数的字符串表示形式。
 StringBuffer
append(String str)
          将指定的字符串追加到此字符序列。
 StringBuffer
append(StringBuffer sb)
          将指定的 StringBuffer 追加到此序列中。
 StringBuffer
appendCodePoint(int codePoint)
          将 codePoint 参数的字符串表示形式追加到此序列。
 int
capacity()
          返回当前容量。
 char
charAt(int index)
          返回此序列中指定索引处的 char 值。
 int
codePointAt(int index)
          返回指定索引处的字符（统一代码点）。
 int
codePointBefore(int index)
          返回指定索引前的字符（统一代码点）。
 int
codePointCount(int beginIndex, int endIndex)
          返回此序列指定文本范围内的统一代码点。
 StringBuffer
delete(int start, int end)
          移除此序列的子字符串中的字符。
 StringBuffer
deleteCharAt(int index)
          移除此序列指定位置的 char。
 void
ensureCapacity(int minimumCapacity)
          确保容量至少等于指定的最小值。
 void
getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
          将字符从此序列复制到目标字符数组 dst。
 int
indexOf(String str)
          返回第一次出现的指定子字符串在该字符串中的索引。
 int
indexOf(String str, int fromIndex)
          从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
 StringBuffer
insert(int offset, boolean b)
          将 boolean 参数的字符串表示形式插入此序列中。
 StringBuffer
insert(int offset, char c)
          将 char 参数的字符串表示形式插入此序列中。
 StringBuffer
insert(int offset, char[] str)
          将 char 数组参数的字符串表示形式插入此序列中。
 StringBuffer
insert(int index, char[] str, int offset, int len)
          将数组参数 str 的子数组的字符串表示形式插入此序列中。
 StringBuffer
insert(int dstOffset, CharSequence s)
          将指定 CharSequence 插入此序列中。
 StringBuffer
insert(int dstOffset, CharSequence s, int start, int end)
          将指定 CharSequence 的子序列插入此序列中。
 StringBuffer
insert(int offset, double d)
          将 double 参数的字符串表示形式插入此序列中。
 StringBuffer
insert(int offset, float f)
          将 float 参数的字符串表示形式插入此序列中。
 StringBuffer
insert(int offset, int i)
          将 int 参数的字符串表示形式插入此序列中。
 StringBuffer
insert(int offset, long l)
          将 long 参数的字符串表示形式插入此序列中。
 StringBuffer
insert(int offset, Object obj)
          将 Object 参数的字符串表示形式插入此字符序列中。
 StringBuffer
insert(int offset, String str)
          将字符串插入此字符序列中。
 int
lastIndexOf(String str)
          返回最右边出现的指定子字符串在此字符串中的索引。
 int
lastIndexOf(String str, int fromIndex)
          返回最后一次出现的指定子字符串在此字符串中的索引。
 int
length()
          返回长度（字符数）。
 int
offsetByCodePoints(int index, int codePointOffset)
          返回此序列中的一个索引，该索引是从给定 index 偏移 codePointOffset 个代码点后得到的。
 StringBuffer
replace(int start, int end, String str)
          使用给定 String 中的字符替换此序列的子字符串中的字符。
 StringBuffer
reverse()
          将此字符序列用其反转形式取代。
 void
setCharAt(int index, char ch)
          将给定索引处的字符设置为 ch。
 void
setLength(int newLength)
          设置字符序列的长度。
 CharSequence
subSequence(int start, int end)
          返回一个新的字符序列，该字符序列是此序列的子序列。
 String
substring(int start)
          返回一个新的 String，它包含此字符序列当前所包含的字符子序列。
 String
substring(int start, int end)
          返回一个新的 String，它包含此序列当前所包含的字符子序列。
 String
toString()
          返回此序列中数据的字符串表示形式。
 void
trimToSize()
          尝试减少用于字符序列的存储空间。

——String类和StringBuffer类相互转换
Eg：StringBuffer s1=“abc 我们的秘密 ”;
String s2=s1.toString(); //StringBuffer类s1转换为String类s2
StringBuffer s3=new StringBuffer(s2); //String 类s2 赋值给StringBuffer类s3

大小写单个字符转换
l 方法一：（将字符转换为字符串型然后使用字符串函数）

public class chapter03_1 {
public static void main(String args[])
{
char arg='a';
Character arg1=new Character(arg);
String arg2=arg1.toString();
System.out.println(arg2.toUpperCase());
}
}

l 方法二：（将字符转换为数值型-32，然后重新转换为字符型）

public class Chapter3 {
public static void main(String[] args) {
char c='s';
int i=c;//将字符型转换为数值型
i=i-32;//将去32
char j=(char)i;//将减去32后的数值型重新转换为字符型
System.out.println("j="+j); }}

数组

数组类型声明正确写法：
l int arry[];
l int []arry;
l int arry[8]; (※错误)
注意：数组的声明和对象引用的含义相同，只表示某个数组，并美欧对应的内存空间。
l in tarry[]=new int[20]
数组名=new 数组元素类型[数组长度];
——申请数组空间

初始化：
l int arry[]={1,2,3,4};

二维数组的行数

数组位置
Eg：数组x定义如下
int x[ ][ ]=new int[3][2]
则 x.length 的值为_3_________，
x[0].length 的值为___2_________。

X[0]列数