❶ java中string怎么使用
以下是关于string的七种用法，注意哦，记得要时常去查看java的API文档，那个里面也有很详细的介绍
1>获取
1.1：字符串中包含的字符数，也就是字符串的长度。
int length():获取长度
1.2：根据位置获取位置上某个字符。
char charAt(int index)
1.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在字符串中出现的位置。
1.4：int lastIndexOf(String str):反向索引。
2>判断
2.1：字符串中是否包含某一个子串。
boolean contains(str);
特殊之处：indexOf(str):可以索引str第一次出现为止，如果返回-1，表示该str不在字符串中存在。
所以，也可以用于对指定判断是否包含。
if(str.indexOf("a")!=1)
而且该方法既可以判断，也可以获取出现的位置。
2.2：字符串中是否有内容。
boolean isEmpty():原理就是判断长度是否为0。
2.3：字符串是否以指定内容开头。
boolean startsWith(str);
2.4：字符串是否以指定内容结尾。
boolean endsWith(str);
2.5：判断字符内容是否相同，复写了object类中的equals方法。
boolean equals(str);
2.6:判断内容是否相同，并忽略大小写。
boolean.equalsIgnorecase();
3>转换
3.1：将字符数组转成字符串。
构造函数：String(char[])
String(char[],offset,count):将字符数组中的一部分转成字符串
静态方法：
static String ValueOf(char[]);
static String ValueOf(char[] data,int offset,int count);
static String valueOf(char[]);
3.2：将字符串转成字符组
char[] tocharArray();
3.3：将字节数组转成字符串。
String(byte[])
String(byte[],offset,count):将字节数组中的一部分转成字符串
3.4：将字符串转成字节数组。
byte[] getBytes()
3.5:将基本数据类型转成字符串，
static String valueOf(int)
static String valueOf(double)
// 3+"" 与 String.valueOf(3)的值是一样的
特殊：字符串和字节数组在转换过程中，是可以指定编码的。
4>替换
String replace(oldchar,newchar);
5>切割
String[] split(regex);
6>子串。获取字符串中的而一部分
String subString(begin);
String subString(begin,end);
7>转换，去除空格，比较。
7.1：将字符串转成大写或小写
String toUpperCsae() 大转小
String toLowerCsae() 小转大
7.2：将字符串两端的多个空格去除
String trim();
7.3：对两个字符串进行自然顺序的比较
int compareTo(string);
请看如下代码，下面的代码都是针对上面string七种用法而进行一一举例说明：
复制代码 代码如下:
class StringMethodDemo
{
public static void method_Zhuanhuan_Qukong_Bijiao()
{
String s = " hello Java ";
//打印结果是：（hello和java前后门都有空格）hello java
sop(s.toUpperCase());
//打印结果是：（HELLO和JAVA前后门都有空格）HELLO JAVA
sop(s.toLowerCase());
//打印及结果是：不带空格的“hello java”
sop(s.trim());
//比较数的大写，打印结果是：1，因为b对应ascii值是98，
//a对应是97，所以b-a=1
String s1 = "abc";
String s2 = "aaa";
sop(s1.compareTo(s2));
}
public static void method_sub()
{
String s = "abcdef";
//打印结果是：cdef，从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界。
sop(s.substring(2));
//打印结果是：cd，包含头，不包含尾。
sop(s.substring(2,4));
}
public static void method_split()
{
String s = "zhangsan,lisi,wangwu";
String[] arr = s.split(",");
for(int x=0; x<arr.length; x++)
{
sop(arr[x]);
}
}
public static void method_replace()
{
String s = "hello java";
//String s1 = s.replace('a','n');
//String s1 = s.replace('w','n'); 如果要替换的字符不存在，返回的还是原串
String s1 = s.replace("java","world");//打印结果是：hello world
sop("s="+s); //打印结果是：hello java因为字符串一旦被初始化，值就不可被改变
sop("s1="+s1);//打印结果是：hello jnvn
}
public static void method_trans()
{
char[] arr = {'a','b','c','d','e','f'};
String s = new String(arr,1,3);
sop("s="+s);//打印结果是：bcd
String s1 = "zxcvbnm";
char[] chs = s1.toCharArray();
for(int x=0; x<chs.length; x++)
{
sop("ch="+chs[x]);//打印结果是：ch=z，x,c,v,b,n,m
}
}
public static void method_is()
{
String str = "ArrayDemo.java";
//判断文件名称是否是Array单词开头
sop(str.startsWith("Array"));
//判断文件名称是否是.java的文件
sop(str.endsWith(".java"));
//判断文件中是否包含Demo
sop(str.contains("Demo"));
}
public static void method_get()
{
String str = "abcdeakpf";
//长度
sop(str.length());
//根据索引获取字符
sop(str.charAt(4));
//sop(str.charAt(40));当访问到字符串中不存在的角标时会发生（字符串角标越界异常）
//根据字符获取索引
//sop(str.indexOf('a'));
sop(str.indexOf('a',3));//打印的是5，因为角标3是d，
//所以从d后面开始找a，第5个角标是a
//sop(str.indexOf('t',3))打印：-1，如果没有找到角标，返回-1
//反向索引一个字符出现的位置(从右往左查找，但是角标还是从左开始)
sop(str.lastIndexOf("a"));
}
public static void main(String[] args)
{
method_Zhuanhuan_Qukong_Bijiao();
//method_sub();
//method_split();
//method_replace();
//method_trans();
//method_is();
//method_get();
/*
String s1 = "abc";
String s2 = new String("abc");
String s3 = "abc";
System.out.println(s1==s2);
System.out.println(s1==s3);
*/
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
❷ java 栈的isEmpty()和empty()有什么区别
isEmpty是从Vector继承的。 两个方法的用途是一样的。
Stack继承Vector是典型的滥用继承的做法。
Stack的文档推荐使用 Deque ，而不是 Stack
Stack Method
Equivalent Deque Method
push(e)
addFirst(e)
pop()
removeFirst()
peek()
peekFirst()
❸ Java中isEmpty方法如何使用
isEmpty()，当字符串长度为0是，返回true，一般作为判断，具体代码如下：
String s = "hello";
if(!s.isEmpty()) {// 当s不为空时，才去做某事事情，
// dosomeing
}
❹ JAVA String 方法 题
private
static
int
count(String
str,String
word){
int
tmpIndex;
int
count;
if(str==null
||
str.isEmpty()){
//空字串直接返回0
return
0;
}
//从字符串的第一个开始找,得到第一个的index
tmpIndex=str.indexOf(word,
0);
count=0;
//如果tmpIndex不等-1，说明str还存在word
while(tmpIndex!=-1){
count++;
//下一个index，从上一个index+1的位置开始查找
tmpIndex=str.indexOf(word,
tmpIndex+1);
}
return
count;
}
❺ 在java中isEmpty（）这个方法怎么使用
JDK版本问题，JDK1.5中的String
类型变量没有isEmpty方法，而JDK1.6中有这个方法，所以只要把你的JDK版本改成1.6的应该没问题。
❻ java String isEmpty() 判断字符串是否为空 有时可以用，有时不可以用， 是跟什么有关系啊！
应该是没什么关系的,你看看是不是无法区分""和null的区别
❼ Java string语句解释
这是个递归调用。逻辑要清楚才能明白。我给你举例说明吧
mixString("abc", "xyz")
用这个比较短的字符做测试。把每一次调用的方法都做上编号。
我们来测试他
public static void main(String[] args) {
String dddd= mixString("abc", "xyz");为了理解，我们把这个mixString称为mixString1
System.out.println(dddd);
}
public String mixString1(String a, String b) {这里a=abc,b=xyz
中间省略
return "" + a.charAt(0)+b.charAt(0)+mixString2(a.substring(1),b.substring(1));
}这里应该返回“”+'a'+'x'+mixString2("bc","yz")的结果；
public String mixString2(String a, String b) {这里a=bc,b=yz
中间省略
return "" + a.charAt(0)+b.charAt(0)+mixString2(a.substring(1),b.substring(1));
}这里应该返回“”+'b'+'y'+mixString3("c","z")的结果；
public String mixString3(String a, String b) {这里a=c,b=z
中间省略
return "" + a.charAt(0)+b.charAt(0)+mixString2(a.substring(1),b.substring(1));
}这里应该返回“”+'c'+'z'+mixString4("","")的结果；
public String mixString4(String a, String b) {这里a="",b=""
if(a.isEmpty() && b.isEmpty())
这里就直接返回“”了
}
好了，现在我们从mixString4把结果带回mixString3
mixString3返回的结果就是“”+'c'+'z'+“”就是“cz”,
mixString2返回的结果就是“”+'b'+'y'+“cz”就是“bycz”,
mixString1返回的结果就是“”+'a'+'x'+“bycz”就是“axbycz”,
不知道你明白了没？递归就像“从前有座山，山里有座庙，庙里有个老和尚讲故事，讲的什么故事？从前有座山、、、、”
❽ java.lang.NoSuchMethodError: java.lang.String.isEmpty()Z怎么解决
String.isEmpty()是JDK1.6新增的方法，低版本的编译环境会报错！
❾ java jdk1.6 string.isempty 和"".equals(string)哪个性能快理由是什么请高人指...
以下是 Java 判断字符串是否为空的三种方法.
方法一: 最多人使用的一个方法, 直观, 方便, 但效率很低.
方法二: 比较字符串长度, 效率高, 是我知道的最好一个方法.
方法三: Java SE 6.0 才开始提供的方法, 效率和方法二几乎相等, 但出于兼容性考虑, 推荐使用方法二.
以下代码在我机器上的运行结果: (机器性能不一, 仅供参考)
function 1 use time: 141ms
function 2 use time: 46ms
function 3 use time: 47ms
public class CompareStringNothing {
String s = "";
long n = 10000000;
private void function1() {
long startTime = System.currentTimeMillis();
for(long i = 0; i<n; i++) {
if(s == null || s.equals(""));
}
long endTime = System.currentTimeMillis();
System.out.println("function 1 use time: "+ (endTime - startTime) +"ms");
}
private void function2() {
long startTime = System.currentTimeMillis();
for(long i = 0; i< n; i++) {
if(s == null || s.length() <= 0);
}
long endTime = System.currentTimeMillis();
System.out.println("function 2 use time: "+ (endTime - startTime) +"ms");
}
private void function3() {
long startTime = System.currentTimeMillis();
for(long i = 0; i <n; i++) {
if(s == null || s.isEmpty());
}
long endTime = System.currentTimeMillis();
System.out.println("function 3 use time: "+ (endTime - startTime) +"ms");
}
public static void main(String[] args) {
CompareStringNothing com = new CompareStringNothing();
com.function1();
com.function2();
com.function3();
}
}
我使用的equals()、length()和JDK6之后的 isEmpty()，在性能上原文分析结果是equals()性能几乎是length()的3.5倍，这个我不敢苟同，我实际测试的结果如下：
equals use time: 110ms
length use time: 78ms
还没到2倍，于是乎我查看了String的源码：
public int length() {
return count;
}
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = count;
if (n == anotherString.count) {
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n-- != 0) {
if (v1[i++] != v2[j++])
return false;
}
return true;
}
}
通过源码我很容易发现length()的效率要高于equals()，length()直接返回String对象的Count属性，而equals()需要先进行判断目标比对对象的类型，然后再进行其它操作，同时还要遍历String对象的每一个char，查看是否相同。
同时原文提到的JDK6提供的String .isEmpty()方法我没有安装JDK6，所以只能替代行的查看了Commons-lang-2.6内StriingUtils的该方法，我相信JDK6的源码与它应该是相同的，源码如下：
public static boolean isEmpty(String str)
{
return (str == null) || (str.length() == 0);
}
可见isEmpty()同样也使用了length()方法，呵呵~只能说apache不傻。
综上我们可以清晰的得出三者性能上的优劣。equals() << length() / isEmpty()