1.类的静态变量操作问题：
package first;
//静态变量
public class Properties {
private static int x=100;
public static void main(String[] args) {
Properties p1=new Properties();
BaseClass one = new BaseClass();
BaseClass two = new BaseClass();
one.setAge(1);
two.setAge(2);
one.setId(0);
two.setId(2);
p1.x++;
Properties p2=new Properties();
p2.x++;
System.out.println("1="+one+one.getId());
System.out.println("2="+two+two.getId());
//这里充分证明了不同对象调用类的静态属性，实际上是对同一属性进行操作
System.out.println("x="+p1.x);
p1=new Properties();
p1.x++;
System.out.println("x="+x);
Properties.x++;
//即使是不同对象，甚至是类名直接调用静态属性，实际上也是对同一属性进行操作
System.out.println("x="+x);
}
}
package reverse;
//实现字符串翻转
public class Reversetest {
public static String reverse(String a){
if(a.length()<=1)
return a;
//核心就是把字符串中间分成左右，然后递归继续分左右，然后把右加左组成
//1.分半
//2.递归分半
String left=a.substring(0,a.length()/2);
String right=a.substring(a.length()/2,a.length());
//递归实现，就是右+左实现翻转
return reverse(right)+reverse(left);
}
public static void main(String[] args) {
String a="abcdefg";
System.out.println(reverse(a));
}
}3.编程实现文件拷贝
package IO;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
/**实现文件拷贝的类
* @author Administrator
*
*/
public final class CopyFile {
private CopyFile(){
throw new AssertionError();
}
//不需要返回值，接受参数为（源文件，目标文件）
public static void fileCopy(String source,String target)throws Exception{
//将源文件写成输入流，简单创建对象
try(InputStream shuru=new FileInputStream(source)){
//将文件写成输出流
try(OutputStream shuchu=new FileOutputStream(target)){
byte[] buffer=new byte[4096];
int byteToReader;
//判断是否还能写
while((byteToReader=shuru.read(buffer))!=-1){
//第一个参数为写入buffer中
shuchu.write(buffer, 0, byteToReader);
}
}
}
}
}
</pre><pre name="code" class="java">package IO;
import java.io.BufferedReader;
import java.io.FileReader;
//写一个方法，输入一个文件名和一个字符串，统计这个字符串在这个文件中出现的次数
public final class CountFile {
private CountFile(){
throw new AssertionError();
}
/**
* @param filename 文件名
* @param words 字符串
* @return 出现次数
* @throws Exception
*/
public static int fileCount(String filename,String words)throws Exception{
int counter=0;
//先读取文件,参数文件名
try(FileReader fr=new FileReader(filename)){
//写入缓存区,参数文件
try(BufferedReader br=new BufferedReader(fr)){
//定义变量表示该行
String line=null;
//若还有行，继续循环
while((line=br.readLine())!=null){
//定义索引值，即该字符的索引
int index=-1;
//内循环条件：1.必须行长度大于该字符长度，才能继续找
//2.就是该字符在改行索引值大于0，获取索引的方法indexOf（相应字符串）
while(line.length()>=words.length()&&(index=line.indexOf(words))>=0){
//没找到该字符串的索引，即表示已经找到该字符串，从此处截掉，剩下的重新赋给line，继续寻找
line=line.substring(index+words.length());
//没截断一次，counter自加一次，表示找到一次
counter++;
}
}
}
}catch(Exception e){
}
//最后返回次数
return counter;
}
}
5.如何用Java代码列出一个目录下所有的文件？
//如果只要求列出当前文件夹下的文件:
package IO;
import java.io.File;
///该代码是只列出文件下所有文件
public class file {
//打开目录下的所有文件，只需列出当前文件夹下的文件
public static void main(String[] args) {
File file=new File("路径");
//类File中listFiles列出所有内容
for(File temp:file.listFiles()){
//判断temp是不是文件，若是打印其名
if(temp.isFile()){
System.out.println(temp.getName());
}
}
}
}//如果需要对文件夹继续展开:
package IO;
import java.io.File;
public class fileOpen {
public static void main(String[] args) {
//new File("路径") 获取目录路径
showDirectory(new File("路径"));
}
/**获取目录下所有的文件并打开
* @param file 为文件目录
*/
public static void showDirectory(File file) {
walkDirectory(file,0);
}
/**
* @param file：根目录
* @param level：文件目录等级
*/
public static void walkDirectory(File file, int level) {
//判断当前文件是否还能打开
if(file.isDirectory()){
//获取当前目录下的所有文件
for(File temp:file.listFiles()){
//将当前文件重新传入，并文件目录等级加1
walkDirectory(temp,level+1);
}
}else{
//若不能打开，进行for循环，逐层进行
for(int i=0;i<level-1;i++){
System.out.println("\t");
}
//获取文件名
System.out.println(file.getName());
}
}
}多线程的服务器，即NIO通信，一个连接对应多个线程
//服务端：
package NIO;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerNIO {
//定义服务器端口号
private static final int serverPort=8090;
public static void main(String[] args) {
//创建ServerSocket对象，服务器端口号初始化
try(ServerSocket server=new ServerSocket(serverPort)){
System.out.println("服务器已经启动");
while(true){
//通过一个while循环进行不断监听，客户端Socket=（服务器）server.accept方法
Socket client=server.accept();
//通过一个请求创建一个线程
new Thread(new ClientHandler(client)).start();
}
}catch(IOException e){
e.printStackTrace();
}
}
public static class ClientHandler implements Runnable{
private Socket client;
public ClientHandler(Socket client){
this.client=client;
}
public void run(){
//try(获取client发送流，将client)
//输入：BufferedReader
//输出：PrintWriter
try(BufferedReader br=new BufferedReader(new InputStreamReader(client.getInputStream()));
PrintWriter pw=new PrintWriter(client.getOutputStream())){
//msg为客户端发送的信息
String msg=br.readLine();
//获取客户端地址
System.out.println(client.getInetAddress());
System.out.println(msg);
pw.println(msg);
pw.flush();
}catch(Exception e){
e.printStackTrace();
}
finally{
try {
client.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}//客户端：
package NIO;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;
public class ClientNIO {
public static void main(String[] args) throws Exception{
Socket client=new Socket("localhost",8090);
Scanner sc=new Scanner(System.in);
System.out.println("请输入内容");
String msg=sc.nextLine();
sc.close();
PrintWriter pw=new PrintWriter(client.getOutputStream());
pw.println(msg);
pw.flush();
BufferedReader br=new BufferedReader(new InputStreamReader(client.getInputStream()));
System.out.println();
client.close();
}
}
扫一扫
776
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
