本文详细介绍了Java中的枚举类型，包括普通枚举和枚举类的创建与使用。接着，文章深入讲解了Java的IO流处理，包括File类的使用，文件字节流和字符流的读写操作，以及缓冲流提高效率的应用。最后，文章提供了文件遍历和文件操作的示例代码。
目录
Java
枚举
普通写法代码如下：
public class EM {
private final String S_NAME;
private final String S_DESC;
private static EM spring=new EM("春天","桃花");
private static EM summer=new EM("夏天","水稻");
private static EM autumn=new EM("秋天","橙子");
private static EM winter=new EM("冬天","雪花");
private EM (String name,String desc)
{
this.S_NAME=name;
this.S_DESC=desc;
System.out.println(this.S_NAME+","+this.S_DESC);
}
public static void main(String[] args) {
EM.getSpring();
EM.getSummer();
EM.getAutumn();
EM.getWinter();
}
public static EM getWinter() {
return winter;
}
public static EM getAutumn() {
return autumn;
}
public static EM getSummer() {
return summer;
}
public static EM getSpring() {
return spring;
}
} 
枚举写代码如下：
public class EM {
public static void main(String[] args) {
Season spring = Season.SPRING;
spring.showInfo();
///Season summer = Season.SPRING;
}
}
enum Season{
SPRING("春天","桃花"),
SUMMER("夏天","西瓜"),
AUTUMN("秋天","橙子"),
WINTER("冬天","雪花");
private final String name;
private final String desc;
private Season(String name,String desc){
this.name=name;
this.desc=desc;
}
public void showInfo(){
System.out.println(this.name+":"+this.desc);
}
}总结：两者比较之下，枚举写的肯定是要简约点的。
IO流
File类
递归遍历文件
代码如下：
public class Main {
public static void main(String[] args) {
System.out.println("D:\\IDEA\\java11\\tt.txt");
}
}
注意：斜杠打两条，一条斜杠是转义字符。
代码如下：
import java.io.File;
public class Main {
public static void main(String[] args) {
//System.out.println("D:\\IDEA\\java11\\tt.txt");
//使用递归遍历文件
File f=new File("D:\\IDEA\\java11\\test1");
new Main().test(f);
}
public void test(File file){
if(file.isFile()){
System.out.println(file.getAbsolutePath()+"是文件");
}
else {
System.out.println(file.getAbsolutePath()+"是文件夹");
File[] fs=file.listFiles();
if(fs!=null&&fs.length>0){
for(File ff:fs){
test(ff);//递归
}
}
}
}
}运行结果：
文件字节流
输入流
代码示例如下：
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class Main {
public static void main(String[] args){
try{
FileInputStream in=new FileInputStream("D:\\IDEA\\java11\\tt.txt");
byte[] b=new byte[1024];
int len=0;
while ((len=in.read(b))!=-1){
System.out.println(new String(b,0,len));
}
in.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}运行结果如下：
注意：流在使用之后一定要关闭。
输出流
import java.io.*;
public class Main {
public static void main(String[] args){
try{
FileOutputStream out=new FileOutputStream("D:\\IDEA\\java11\\tt1.txt");
String str="dfvkndbkvfbdkggfjk";
out.write(str.getBytes());
out.flush();
out.close();
} catch (FileNotFoundException ex) {
throw new RuntimeException(ex);
} catch (IOException ex) {
throw new RuntimeException(ex);
}
}
}
结果：
练习
代码如下：
import java.io.*;
public class Main {
public static void main(String[] args) {
Main.copyFile();
}
public static void copyFile() {
try {
FileInputStream in=new FileInputStream("D:\\IDEA\\java11\\tt.txt");
FileOutputStream out=new FileOutputStream("D:\\IDEA\\java11\\tt2.txt");
byte[]b=new byte[100];
int len=0;
while((len=in.read(b))!=-1){
out.write(b,0,len);
}
out.flush();
out.close();
in.close();
}
catch (Exception e) {
throw new RuntimeException(e);
}
}
}
结果如下：
文件字符流
输入流
示例如下：
import java.io.FileReader;
public class Test2 {
public static void main(String[] args){
Test2.hdFile("D:\\IDEA\\java11\\tt.txt");
}
public static void hdFile(String inPath){
try {
FileReader fr=new FileReader(inPath);
char [] c=new char[10];
int len=0;
while((len=fr.read(c))!=-1){
System.out.println(new String(c,0,len));
}
fr.close();
}
catch (Exception e) {
throw new RuntimeException(e);
}
}
}
结果如下：
输出流
示例如下：
import java.io.FileReader;
import java.io.FileWriter;
public class Test2 {
public static void main(String[] args){
Test2.hdFile("D:\\IDEA\\java11\\tt.txt");
Test2.scFile("wcb","D:\\IDEA\\java11\\tt3.txt");
}
public static void scFile(String text,String outPath){
try{
FileWriter fw=new FileWriter(outPath);
fw.write(text);
fw.flush();
fw.close();
}
catch (Exception e) {
throw new RuntimeException(e);
}
}
}
结果：
缓冲流
它主要是为了提高速度，有点像高速缓存。
示例如下（有抛出异常和捕获异常）：
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.FileWriter;
public class Test2 {
public static void main(String[] args){
try {
Test2.hcsr( );
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static void hcsr() throws Exception{
FileInputStream in=new FileInputStream("D:\\IDEA\\java11\\tt3.txt");
BufferedInputStream br=new BufferedInputStream(in);
byte[] b=new byte[10];
int len=0;
while ((len=br.read(b))!=-1){
System.out.println(new String(b,0,len));
}
br.close();
in.close();
}
}结果：
java小总结：其实因为有C语言的基础，就目前来讲java学起来不是很困难，主要还是要注意一下与C语言的不同，注意一些语法什么的，还有就是那些类和方法什么的，它给在里面了，得会用能用，所以记忆和复盘还是重点，等看完java之后就去重点看一下java的重点知识，然后去看mysql和maven，快点学完然后一边复盘学习一边写项目设计思路，然后写项目。
vju
分析：
这个题目吧，不难，但是容易时间超限，所以剪枝操作一定要做好，不然就嘎嘎时间超限。唉，，，说多了都是泪
剪枝操作主要是下面三个：
1，如果当前搜索到的最小表面积已经大于了已知的最小表面积直接退出
2，如果当前搜索到的体积已经超过题目限制则退出
3，如果由体积推出来当前的表面积已经不优直接退出
从下往上搜，每次枚举采取块大的先枚举，这样方案数少，假设当前体积为v，总体积为n , 剩余体积 n-v，圆柱体积为 r*r*h，若要使 r 尽可能大,则令h=1即可，r <= sqrt(n-v)，当r确定了后, h = (n-v)/(r*r)。
代码如下：
#include<stdio.h>
#include<math.h>
#include<string.h>
int n,m;
int min=1e9+7;
void dfs(int n1,int r,int h,int a,int v)
{
if(v>n||n1>m||a>min)
return;
if(n1==m&&v==n)
{
min=a;
return;
}
if (v+(h*r*r)*(m-n1) <= n)//剪枝，不然就会时间超限
return;
for(int h1=h-1;h1>=m-n1;h1--)
{
for(int r1=r-1;r1>=m-n1;r1--)
{
dfs(n1+1,r1,h1,a+2*r1*h1,v+r1*r1*h1);
}
}
}
int main()
{
scanf("%d",&n);
scanf("%d",&m);
for (int h=n/(m*m);h>=m;h--)
{
for (int r=sqrt(n/m);r>=m;r--)
{
dfs(1,r,h,r*r+2*r*h,h*r*r);
}
}
if(min==1e9+7)
printf("0");
else
printf("%d",min);
}
分析：
其实我这个代码是写得相当臃肿的，这个题好一点的方法应该是使用双向广搜，我没有用双向广搜，我用了两次广搜，然后记录下他们的位置，到每个点上需要的时间，然后再讲这个时间加起来比较，但是！！！！注意一个点，一定要注意
我当时就是这里没有注意到，然后一直错，不是只比较kfc那个位置上两个步数之和的最小值就行，你还要判断他们是不是都走到过这家kfc。
代码如下：
#include<stdio.h>
#include<math.h>
#include<string.h>
int m,n;
int a[2][201][201],xx,yy,k;
char c[201][201],cc;
int b[201][201];
int d[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
struct fff
{
int x;
int y;
int s;
}map[201*201];
void cz(char ccc)
{
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
if(c[i][j]==ccc)
{
xx=i;
yy=j;
return;
}
}
}
void bfs()
{
int tail,head;
tail=head=1;
cz(cc);
map[tail].x=xx;
map[tail].y=yy;
map[tail].s=0;
b[xx][yy]=1;
tail++;
while(head<tail)
{
for(int i=0;i<4;i++)
{
int nx=map[head].x+d[i][0];
int ny=map[head].y+d[i][1];
if(nx<0||nx>=n||ny<0||ny>=m||b[nx][ny]||c[nx][ny]=='#')
continue;
b[nx][ny]=1;
map[tail].x=nx;
map[tail].y=ny;
map[tail].s=map[head].s+1;
a[k][nx][ny]=map[tail].s;
tail++;
}
head++;
}
}
void minn()
{
int min=400000;
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
{
if(c[i][j]=='@'&&a[0][i][j]&&a[1][i][j])
{
if(a[0][i][j]+a[1][i][j]<min)
min=a[0][i][j]+a[1][i][j];
}
}
}
printf("%d\n",min*11);
}
int main()
{
while(scanf("%d%d",&n,&m)!=EOF)
{
for(int i=0;i<n;i++)
scanf("%s",c[i]);
//for(int i=0;i<n;i++)
//printf("%s\n",c[i]);
k=0;
cc='Y';
for(int i=0;i<201;i++)
for(int j=0;j<201;j++)
b[i][j]=0;
bfs();
k=1;
cc='M';
for(int i=0;i<201;i++)
for(int j=0;j<201;j++)
b[i][j]=0;
bfs();
minn();
for(int z=0;z<2;z++)
for(int i=0;i<201;i++)
for(int j=0;j<201;j++)
a[z][i][j]=0;
}
}分析：
这个题目没有什么要特别注意的点就是自己要想明白读懂题意，然后就是一直的搜索加比较，用深搜就行。
#include<stdio.h>
#include<math.h>
#include<string.h>
int n;
int a[16][16],b[16];
int sum;
void dfs(int h,int l,int sj)
{
for(int i=0;i<n;i++)
{
if(b[i]||a[h][i]<sj)
continue;
b[i]=1;
dfs(i,l+1,a[h][i]);
b[i]=0;
}
sum=sum>l?sum:l;
}
int main()
{
while(scanf("%d",&n)!=EOF)
{
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
scanf("%d",&a[i][j]);
}
b[i]=0;
}
a[0][0]=0;
sum=0;
b[0]=1;
dfs(0,1,0);
printf("%d\n",sum);
}
}
cf
上场的cf，我做出来了的题目都没有什么需要注意的点，只是还是要注意一个时间复杂度，然后数组什么的开大点，但是这两天还没有来得及补题，所以还不是很知道后面的题目会怎么样，明天应该可以把cf和atc的题目补一半，然后再想一下蚂蚁过桥的问题和思维版奶牛翻块问题。
1183
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
