javastring实现

A. java 中string类怎么实现

ava字符串类(java.lang.String)是Java中使用最多的类，也是最为特殊的一个类，很多时候，我们对它既熟悉又陌生。
一、从根本上认识java.lang.String类和String池
首先，我建议先看看String类的源码实现，这是从本质上认识String类的根本出发点。从中可以看到：
1、String类是final的，不可被继承。public final class String。
2、String类是的本质是字符数组char[], 并且其值不可改变。private final char value[];
然后打开String类的API文档，可以发现：
3、String类对象有个特殊的创建的方式，就是直接指定比如String x = "abc"，"abc"就表示一个字符串对象。而x是"abc"对象的地址，也叫
做"abc"对象的引用。
4、String对象可以通过“+”串联。串联后会生成新的字符串。也可以通过concat()来串联，这个后面会讲述。
6、Java运行时会维护一个String Pool（String池），JavaDoc翻译很模糊“字符串缓冲区”。String池用来存放运行时中产生的各种字符串，
并且池中的字符串的内容不重复。而一般对象不存在这个缓冲池，并且创建的对象仅仅存在于方法的堆栈区。

B. java怎么实现String的引用传递

1、定义全局变量 ，两种方法，可以在方法内任意对其重新赋值，方法内变量名要与全局变量相同，也可以使用return新字符串，调用时重新赋值
2、定义局部变量 ，一种方法，只能通过调用方法return新字符串，对原字符串重新赋值

C. 在java中如何实现把String类型转化为Time类型，例如：hh:mm:ss格式

java中实现把String类型的时间转换成Time类型的时间可以使用SimpleDateFormat来转换。
具体事例代码实现如下：
public class Demo2 {
public static void main(String[] args) {
String str = "2015-01-01 12:12:12";//定义一个字符型的时间
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = null;
try {
date = (Date) simpleDateFormat.parse(str);//将这个字符型的时间转换成Date型的时间
} catch (ParseException e) {
e.printStackTrace();
}
System.out.println(date.toString());
}
}
SimpleDateFormat 是 Java 中一个非常常用的类，该类用来对日期字符串进行解析和格式化输出。

D. 求java实现String list[] = { "1", "2", "3" }; 的排列组合代码

对于这个问题，我首先需要纠正一下楼主的措辞，这是个组合问题，跟排列无关，用排列组合亦不恰当。下面说下我的想法
元素不能重复，首先应该去掉相同的元素，最好的办法是用set来实现。参考api
Arrays.asList
set.addAll
其实呢，这个是一个递归的过程，考虑下面情况
对于数组
{“1”}，它的组合数就是{“1”}。
如果再加上一个元素“2“到上面的数组中，那么，如果这个”2“不用，实质上跟{"1"}的情况是一样的，这与不能重复相矛盾，所以”2“一定要用，就是在"1"中再加上”2“；于是我们得到
对于数组{”1“，”2“}它的组合数是{”1“}
再加入一个{”2“}。也许你也考虑到另外一种情况，即”2“也是它的一个组合数，我们考虑丢了，为什么呢，因为在{”1“}中实质上还有一个称为空的集合。这样的话，重新整理一下：
1.对于list
=
{"1"},它的组合包括
{"1"},以及
empty.
2.对于list={"1","2"},它的组合包括{”1“，”2“}（在{”1“}中加了”2“），{”2“}（在empty中加入”2“），也许你还会讲还应该包括{”1“}，但是这个{”1“}我们已经在第1步就已经算出来了，不用再考虑了。
按照这样的规则进行下去，你会发现这样就把所有的组合数遍历出来了。要具体的代码就等会儿，我现在有事。

E. 如何用JAVA实现这些String类，求完整程序

您好，这样的：
/* StrDemo.java*******
**********************/
class StrDemo
{
public static void main(String args[])
{
String str1=new String("abcdefg");
String str2=new String("higklmn");
String str3=new String("abc");
String str4=new String();

System.out.println("str1的长度是"+str1.length());

int i=3;
System.out.println("第"+i+"个位置上的字符为"+str1.charAt(i));

if(str1.equals(str2)) str3="相等";
else str3="不相等";
System.out.println("str1和str2"+str3);
}
}

F. java关于String[] str = new String[]{};

大括号的作用是初始化。

String[]str = new String[]{}；

大括号的意思是初始化，前面定义的String[]str ;

但是现在大括号里面是空的，也就是没有内容，打印str的长度是0，但是如果这样定义String[]str = new String[]{“111”,"22222"}；str的长度就为2。

String类有个构造方法 String（byte ascii[]，int hiByte）；此方法是以字节数组的形式生成一个字符串，数组中存放字符申各字符对应的ASCII码。

为了和使用 1～3字节表示一个代码的 UTF（Unicode Text Format）兼容，这个构造方法的入口参数中用hiByte指出每个代码含几个高位字节。对于ASCII码而言，因为只有1个字节，而没有高位字节，所以，hiByte的值为0，但对其他字符，hiByte的值可能为1或2。

(6)javastring实现扩展阅读：

当编辑并运行一个Java程序时，需要同时涉及到这四种方面。使用文字编辑软件（例如记事本、写字板、UltraEdit等）或集成开发环境（Eclipse、MyEclipse等）在Java源文件中定义不同的类，通过调用类（这些类实现了Java API）中的方法来访问资源系统，把源文件编译生成一种二进制中间码；

存储在class文件中，然后再通过运行与操作系统平台环境相对应的Java虚拟机来运行class文件，执行编译产生的字节码，调用class文件中实现的方法来满足程序的Java API调用。

G. Java怎么实现输入一个string表达式然后输出计算的结果

import java.io.*;
import java.util.*;
class BinaryTree{
BinaryTree left=null;
BinaryTree right=null;
char data=0;
}
public class Calculator{
String porder="";
public void postorder(BinaryTree bt){
//递归后序遍历二叉树
if(bt!=null){
postorder(bt.left);
postorder(bt.right);
porder+=bt.data;
}
}
public int calc(String s){
//计算后缀表达式的值
int i=0,len=0,a=0,b=0;
Stack stack=new Stack();
len=s.length();
for(;i<len;i++){
char c=s.charAt(i);
switch(c){
case '+':
a=(int)stack.pop();
b=(int)stack.pop();
stack.push(a+b);
break;
case '-':
b=(int)stack.pop();
a=(int)stack.pop();
stack.push(a-b);
break;
case '*':
a=(int)stack.pop();
b=(int)stack.pop();
stack.push(a*b);
break;
case '/':
b=(int)stack.pop();
a=(int)stack.pop();
stack.push((int)a/b);
break;
default:
//该字符是数字
stack.push(c-'0');
}
}
return stack.pop();
}
public BinaryTree create(String s){
//构造二叉树结点(递归)
int i=0,pos=0,len=0;
String l="",r="";
BinaryTree node=new BinaryTree();
len=s.length();
if(len==0) return null;
if(len==1){
//递归边界
node.data=s.charAt(0);
return node;
}
//去括号
while((pos=s.indexOf(")"))!=-1){
i=pos;
while((s.charAt(i)!='(')&&(i>0)) i--;
String sub=s.substring(i+1,pos);//括号中的表达式
porder="";
postorder(create(sub));//得到后缀表达式
int sum=calc(porder);//计算后缀表达式的值,替换原来括号中的表达式
s=s.substring(0,i)+String.valueOf(sum)+s.substring(pos+1);
len=s.length();//重新计算s的长度
}
//从后往前扫描得到的第一个优先级最低的运算符号的位置
pos=-1;
for(i=len-1;i>0;i--){
char c=s.charAt(i);
if((c=='+')||(c=='-')){
pos=i;
break;
}
else if(((c=='*')||(c=='/'))&&(pos==-1)) pos=i;
}
//在pos位置将s分为左右两部分,递归构造左右两个部分的二叉树
l=s.substring(0,pos);
r=s.substring(pos+1);
node.data=s.charAt(pos);
node.left=create(l);
node.right=create(r);
return node;
}
public static void main(String args[]) throws Exception{
BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
String s=reader.readLine();
Calculator c=new Calculator();
BinaryTree bt=c.create(s);
c.postorder(bt);
System.out.println(c.calc(c.porder));
}
}

H. java中怎么实现String类型变量作为函数参数

public void test(String str)｛
System.out,println(str);
｝

I. java中如何实现string的第一个字母大写

以下是方法：

publicstaticStringdo17(Stringstr){

J. java读取text文件为String，如何实现

/**
* 主要是输入流的使用，最常用的写法
* @param filePath
* @return
*/
public static String read(String filePath)
{
// 读取txt内容为字符串
StringBuffer txtContent = new StringBuffer();
// 每次读取的byte数
byte[] b = new byte[8 * 1024];
InputStream in = null;
try
{
// 文件输入流
in = new FileInputStream(filePath);
while (in.read(b) != -1)
{
// 字符串拼接
txtContent.append(new String(b));
}
// 关闭流
in.close();
}
catch (FileNotFoundException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
if (in != null)
{
try
{
in.close();
}
catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
return txtContent.toString();
}