String
类
STRING
其实是
CHAR
类型组成的数组
—
字符串
String str = "abc";
等效于：
char data[] = {'a', 'b', 'c'};
String str = new String(data);
介绍几个常用的方法
length()
返回此字符串的长度
toLowerCase()
转化字符串中的英文字符变成小写
toUpperCase()
转化字符串中的英文字符变成大写
public class StringDemo1
{
public static void main(String[] args)
{
String text="Hello";
System.out.println("
字符串的内容：
"+text);
System.out.println("
字符串的长度：
"+text.length());
System.out.println("
时候等于
hello? "+text.equals("hello"));
System.out.println("
转化成大写：
"+text.toUpperCase());
System.out.println("
再转化成小写：
"+text.toLowerCase());
}
}
运行结果：
字符串的内容：
Hello
字符串的长度：
5
时候等于
hello? false
转化成大写：
HELLO
再转化成小写：
hello
取得字符串中字符的方法
char charAt(int index)
返回指定索引处的字符
int indexof(int ch)
返回指定字符第一个找到的索引位置
int indexOf(String Str)
返回指定字符串第一个找到的索引位置
int lastIndexof(int ch)
返回指定字符
最后一个
找到的位置
String substring(int beginIndex)
取出指定索引处至字符串尾端的子字符串
String
substring(int beginIndex, int endIndex)
返回一个新字符串，它是此字符串的一个子字符串。
取出索引范围
char[] toCharArray()
将字符串转化为字符数组
一个字符串一旦被配置，他的内容就是固定不变的。
在
JAVA
中如果
==
被使用于两个对象类型的变量，它是用于比较两个变量是否引用自同一个对象。
public class CharAtString
{
public static void main(String[] args)
{
String text="one's left brain has nothing right.\n"+"One's right brain has nothing left.\n";
System.out.println("
字符串内容：
");
for (int i=0;i<text.length();i++ )
{
System.out.print(text.charAt(i));
}
System.out.print("\n
第一个
left:"+text.indexOf("left"));
System.out.print("\n
最后一个
left:"+text.lastIndexOf("left"));
//
将字符串转化成字符数组
char[] charArr=text.toCharArray();
System.out.println("\n\n
打印出被转化成字符数组的内容
:");
for (int i=0;i<charArr.length;i++)
{
System.out.print(charArr[i]);
}
}
}
public class InternString
{
public static void main(String[] args)
{
String str1="fly";
String str2="weight";
String str3="flyweight";
String str4=null;
str4=str1+str2;
//
注意这里的结果是
false
System.out.println(str3==str4);
//
这样的结果是
true
System.out.println(str3.equals(str4));
str4=(str1+str2).intern();
//intern()
返回字符串对象的规范化形式
如果池已经包含一个等于此
String
对象的字符串
//
则返回池中的字符串
System.out.println(str3==str4);
}
}
public class FileFilter
{
public static void main(String[] args)
{
//
测试以
**
为结尾的方式
String[] filenames={"catepillar.jpg","cater.gif","bush.jpg","wwwu.jpg","clockman.jpg"};
System.out.print("
过滤出
jpg
文件
:");
for(int i=0;i<filenames.length;i++)
{
if(filenames[i].endsWith(".jpg"))
{
System.out.print(filenames[i]+" ");
}
}
}
}
public class AppendStringTest
{
public static void main(String[] args)
{
String text="";
long beginTime=System.currentTimeMillis();
for(int i=0;i<10000;i++)
text=text+i;
long endTime=System.currentTimeMillis();
System.out.println("
执行时间
:"+(endTime-beginTime));
StringBuilder builder=new StringBuilder("");
beginTime=System.currentTimeMillis();
for (int i=0;i<10000;i++)
{
builder.append(String.valueOf(i));
}
endTime=System.currentTimeMillis();
System.out.println("
执行时间
:"+(endTime-beginTime));
}
}
public class CommandLineArg
{
public static void main(String[] args)
{
System.out.print("
读入的变量
:");
for(int i=0;i<args.length;i++)
{
System.out.print(args[i]+"");
}
System.out.println();
}
}
public class CommandLineArg2
{
public static void main(String[] args)
{
System.out.print("
读入的变量
:");
for(String arg:args)
System.out.print(arg+" ");
System.out.println();
}
}
J2SE5.0
的版本引入了
StringBulider
类这个类在和
+
来对比的时候提高了效率。所以
不建议用
+
来进行字符串的连接。
JAVA
中的
foreach
JDK 5.0
中增加了一些新的特性
,
但是以前只是肤浅的了解了一下
,
只知道怎么回事
,
但是根本没有用心去学习
,
最近觉得自己学习太浮躁了
.
先学着做一些笔记吧
.
慢慢养成习惯吧
.
JDK5.0
中对
for
语句增加了一种形式
,
和其他语言中的
foreach
比较像
,
所以题目取名叫
JAVA
中的
foreach.
该形式的具体语法如下
:
for(
声明
:
表达式
)
.
解释一下
,
也就是说冒号前面是声明一个临时变量
,
在下面的语句中进行引用
.
冒号后面是表达式
,
应该为集合或者数组
这样看起来可能不太明白
.
用实例看一下
:
for (Object listElement : list) {
System.out.println(listElement.toString());
// Do something else with this list element
}
这样是不是简介了许多
?
list
为一个
list
对象
.JDK5
以前的实现方式一般是加一个临时变量
i,
或者是用
iterator.
代码如下
:
for (Iterator i = list.iterator(); i.hasNext(); ) {
Object listElement = i.next();
out.println(listElement.toString());
// Do something else with this list element
}
或者
for (int i=0;i<list.size();i++) {
Object listElement = list.get(i);
out.println(listElement.toString());
// Do something else with this list element
}
相比之下
,
这个
for
的新的形式确实是使代码简洁不少
.
那么这种形式的原理是什么呢
?
它做法很聪明
,
只是在编译的时候转换成如下形式
:
for (Iterator<E> #i = (expression).iterator(); #i.hasNext(); ) {
declaration = #i.next();
statement
}
这样估计减少了修改
javac
的工作量
.
这样做还有一个优点
:
如果你想用自己定义的集合来使用这种形式
,
很简单
,
只需要实现
java.lang.iterable
接口就可以了
.
任何事物都有两面
,
这样做的缺点是什么呢
?
这种形式的一个最大的缺点就是不能访问元素在这个集合中的定位
,
举个例子来说
:
for (int i=0; i<args.length; i++) {
wordList.add("word " + (i+1) + ": '" + args[i] + "'");
}
for (String word : wordList) {
out.println(word);
}
这两个例子说明了问题
.
没法访问定位
,
也就没办法修改
,
删除这个集合中的内容
.
前面已经说了
,
这种形式是转换为
Iterator
形式使用的
.
所以
Iterator
能做到的
,
他就能做到
.
这种写法这么简洁
,
如果你只是要遍历这个集合
,
数组
,
这种写法非常适合
.
这里还有需要注意的一个问题
,
数组集合中如果是对象的话
,
在声明中要定义成
Object
类型
,
不要定义成集合中数据的类型
,
比如下面的代码
:
List list=new ArrayList();
list.add("test1");
list.add("test2");
list.add("test3");
list.add("test4");
for(String test:list){
System.out.println(test);
}
这种写法会报错
,
因为
Iterator
本来就是返回的
Object
对象
,
不能从
Object
转为
String.
可以通过
JDK5
中的范型来解决
,
可以写成下面的形式
:
List<String> list=new ArrayList<String>();
list.add("test1");
list.add("test2");
list.add("test3");
list.add("test4");
for(String test:list){
System.out.println(test);
}
IBM
官方网站的一篇文章
正则表达式的构造摘要
| |
|
|
|
|
构造
|
匹配
|
|
|
|
|
字符
| |
|
x
|
字符
x
|
|
\\
|
反斜线字符
|
|
\0n
|
带有八进制值
0
的字符
n (0<=n<=7)
|
|
\0nn
|
带有八进制值
0
的字符
nn (0<=n<=7)
|
|
\0mnn
|
带有八进制值
0
的字符
mnn
（
0<=m<=3
、
0<=n<=7
）
|
|
\xhh
|
带有十六进制值
0x
的字符
hh
|
|
\uhhhh
|
带有十六进制值
0x
的字符
hhhh
|
|
\t
|
制表符
('\u0009')
|
|
\n
|
新行（换行）符
('\u000A')
|
|
\r
|
回车符
('\u000D')
|
|
\f
|
换页符
('\u000C')
|
|
\a
|
报警
(bell)
符
('\u0007')
|
|
\e
|
转义符
('\u001B')
|
|
\cx
|
对应于
x
的控制符
|
|
|
|
|
字符类
| |
|
[abc]
|
a
、
b
或
c
（简单类）
|
|
[^abc]
|
任何字符，除了
a
、
b
或
c
（否定）
|
|
[a-zA-Z]
|
a
到
z
或
A
到
Z
，两头的字母包括在内（范围）
|
|
[a-d[m-p]]
|
a
到
d
或
m
到
p
：
[a-dm-p]
（并集）
|
|
[a-z&&[def]]
|
d
、
e
或
f
（交集）
|
|
[a-z&&[^bc]]
|
a
到
z
，除了
|
扫一扫
2373
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
