import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;
public class Test {
public static int ci = 0; //定义次数
public static void xitong() {
String path = "C:\\Users\\lenovo\\Desktop\\Test.txt";//文件路径
File file = new File(path);
file.delete();//删除原来文件
File parentFile = file.getParentFile();//得到上一级文件夹
if(!parentFile.exists())
{
parentFile.mkdirs();//创建当前文件夹，以及父路径不存在的文件夹
}
if(!file.exists())
{
try
{
file.createNewFile();//创建一个空文件
} catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
User[] user = new User[6];//客户数组
user[0] = new User("admin", "admin123", "11111111111");
user[1] = new User("ABC", "abcabc", "11111111111");
user[2] = new User("BCD", "bcdbcd", "11111111111");
user[3] = new User("CDE", "cdecde", "11111111111");
user[4] = new User("DEF", "defdef", "11111111111");
user[5] = new User("EFG", "efgefg", "11111111111");
for (int i = 0; i < user.length; i++) {
writer(user[i], path);//将客户信息写入文件
}
ZhuJieMian jieMian = new ZhuJieMian();
boolean m = false;
while(!m)
{
jieMian.denglu();//输出想要的字符串
Scanner scan = new Scanner(System.in);
int i = scan.nextInt();//选择功能
while (!(i == 1 || i == 2 ))
{
System.out.println("输入错误，请重新输入！");
i = scan.nextInt();
}
switch (i)
{
case 1:
ZhuCe ce = new ZhuCe();//注册类
writer(ce.zhuce(), path);
m = false;
break;
case 2:
boolean b = true;
Scanner scan1 = new Scanner(System.in);
A:while (b)
{
DengLu(path, scan, scan1,file);//登陆方法
}
break;
default:
break;
}
}
}
private static void DengLu(String path, Scanner scan, Scanner scan1,File file) {
System.out.println("请输入用户名：");
String inputStr = scan1.nextLine();
FileReader fr = null;
StringBuffer buffer = null;
try
{
fr = new FileReader(path);
int len = 0;
char[] cbuf = new char[500];
buffer = new StringBuffer();
while(-1 != (len = fr.read(cbuf)))
{
buffer.append(new String(cbuf,0,len));//将文件中的字符串写入buffer
}
} catch (FileNotFoundException e)
{
e.printStackTrace();
} catch (IOException e)
{
e.printStackTrace();
}
String[] read = buffer.toString().split(";");//将buffer分解成数组
String[][] read1 = new String[read.length][];
for (int j = 0; j < read1.length; j++) {
read1[j] = read[j].split(",");
}
HashMap<String, User> hashMap = new HashMap<>();
for (int j = 0; j < read1.length; j++) {
hashMap.put(read1[j][0], new User(read1[j][0], read1[j][1], read1[j][2]));//将客户信息写入hashMap容器
}
if(hashMap.get(inputStr) != null)
{
System.out.println("请输入密码：");
String inputStr1 = scan1.nextLine();
if(inputStr1.equals(hashMap.get(inputStr).password))//判断密码
{
if(inputStr1.equals("admin123"))//当客户名为管理员的用户名
{
boolean d = true;
while(d)
{
System.out.println("用户信息：");
Collection<User> values = hashMap.values();
// 第一种
// 获取map中保存key的容器
Set<String> keySet = hashMap.keySet();
Iterator<String> iterator = keySet.iterator();
while(iterator.hasNext())
{
String key = iterator.next();
User valus = hashMap.get(key);
if(valus.user_name.equals("admin"))
{
continue;
}
System.out.println("用户名： "+valus.user_name+"，密码： "+valus.password+"，电话： "+valus.tel);
}
System.out.println("你可以选择删除功能，确认请输入1，输入2返回上一级，其他输入退出系统！");
String j = scan.next();
if(j.equals("1"))
{
boolean c = true;
while(c)
{
System.out.println("请输入你要删除用户的用户名：");
String string1 = scan.next();
if(hashMap.get(string1) != null)
{
hashMap.remove(string1);
c = false;
}else
{
System.out.println("输入错误，请重新输入！");
}
}
}else if(j.equals("2"))
{
d = false;
}else
{
System.out.println("感谢您应用本系统，再见！");
file.delete();
}
}
}else
{
System.out.println("登录成功!");
file.delete();
}
}
else
{
System.out.println("输入错误，请重新输入！");
}
}else
{
System.out.println("输入错误，请重新输入！");
}
}
public static void writer(User user,String path) //将客户信息写入文件
{
String str = user.toString();
FileWriter fw = null;
try
{
fw = new FileWriter(path,true);
fw.write(str);
fw.flush();
} catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}finally
{
if(fw != null)
{
try
{
fw.close();
} catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
这是一个用户登录注册的作业，虽然看是简单，当时需要一定的java基础和逻辑能力，我们需要不断练习，熟练代码。
StringBuffer 代表可变的字符序列
//构造方法
StringBuffer buffer = new StringBuffer();//默认16
StringBuffer buffer1 = new StringBuffer("123");//字符串长度+16
StringBuffer buffer2 = new StringBuffer(20);//设置长度
buffer1.append(123).append(12.4).append(true).append("asd");
//如果添加的数据超出缓冲区的长度，他会自动扩充，扩充的长度为原长度的两倍+ 2
System.out.println(buffer1.toString());
//StringBuffer特有的，对StringBuffer立面保存的字符进行操作，但是不会产生新的对象
buffer1.insert(1, "=====");
System.out.println(buffer1.toString());
buffer1.delete(2, 5);//包左不包右
System.out.println(buffer1.toString());
buffer1.reverse();//反向字符串
System.out.println(buffer1.toString());
buffer1.replace(0, 5, "++++");//包左不包右
System.out.println(buffer1.toString());
//跟字符串类似
System.out.println(buffer1.capacity()+ "1");//空间长度
System.out.println(buffer1.length() + "a");
buffer1.setLength(10);
System.out.println(buffer1.capacity()+ "2");
System.out.println(buffer1.length() + "b");//实际字符长度
System.out.println(buffer1.toString());
System.out.println(buffer1.charAt(5));Character 静态方法：
isDigit(char ch) 判断是否是数字 |
isLetter(char ch) 判断是否字母 |
isLowerCase(char ch) 确定指定字符是否为小写字母。 |
isUpperCase(char ch) 确定指定字符是否为大写字母。 |
单实例模式 单态模式 SingleTon
步骤：
1、私有化构造方法
2、声明一个private final static 的成员变量，类型为当前类型，去实例化一个当前类型的对象。
3、声明一个public static的方法用户获取当前类型的成员变量
异常捕获：
try{
//可能出现异常的地方，
}catch（Exception e）
{
System.out.println(e.getMessage());//得到异常信息
e.printStackTrace();//打印异常栈信息
}
Exception
RuntimeException 运行时异常
运行时出现的错误 ，而且这类异常出现的概率比较高，所以一般我们是不会去捕获
常见运行时异常：
ArithmeticException 数学运算异常
NullPointerException 空指针异常
StringIndexOutOfBoundsException 字符串索引越界
ArrayIndexOutOfBoundsException 数组下标越界
NegativeArraySizeException 数组定义异常
IllegalArgumentException 非法参数异常
注意： 不需要try{}catch(){}捕获，要看的懂异常的原因，通过修改代码区捕获它。
Check Exception 检查异常
在语法上需要去捕获
IOException
try{}catch(){}catch(){}
try之后可以有多个catch 但是要保证catch之后捕获的异常类型要有一定的顺序（子类在上父类在下）
finally 在catch之后：不管try中代码有没有出现错误都必须执行
throws
在方法之后声明调用该方法可能抛出某种异常，可以声明抛出多个。
RuntimeException可以不用声明被捕获
throw
throw在具体的某个位置抛出某个异常，一旦被执行，以下的代码就结束。
但是可以用try{}catch（）{}直接捕获
重写中方法异常抛出的声明：
1、重写是可以不声明抛出异常
2、重写方法不可以抛出被重新方法声明之外的异常（运行时异常除外）
自定义异常：
使用自定义异常一般有如下步骤：
1、通过继承 java.lang.Exception 类声明自己的异常类。
2、在方法适当的位置 生成自定义异常的实例，并用throw 语句抛出。
3、 在方法的声明部分用throws 语句声明该方法可能抛出的异常。
Set 接口
无序不可重复
无序：不按照添加先后，添加完之后有一定的顺序
Set接口没有新增的方法，所有的放都是Collection继承过来的。
主要实现类：
HashSet
顺序：按hash码排列
List接口
有顺序可以重复
主要实现类：
ArrayList
LinkedList
list新增了
remove（int index）//移除索引的元素
remove(Object o)//具体的元素
Iterator 迭代器
Collection接口 有声明 iterator() 方法
ArrayList中 ：
toArray() 把容器里面的元素转换成数组里面的元素
toArray(T[] t)声明一个数组，然后把容器里面的元素按照原来顺序赋值到数组当中
removeRange(int fromIndex, int toIndex)移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。（包级） |
注意： ArrayList中的常用API要熟练
容器：
LinkedList
addFirst(E e)将指定元素插入此列表的开头。 |
addLast(E e)将指定元素添加到此列表的结尾。 |
pop()从此列表所表示的堆栈处弹出一个元素。 |
push(E e)将元素推入此列表所表示的堆栈。 |
Map
key - value 保存数据
1、key是不可以重复
2、value是可以重复的
HashMap
hashmap数据添加是无序
按照key的hashcode排序
作为key的类型，必须重写hashcode equlse
map遍历
// 第一种
// 获取map中保存key的容器
Set<String> keySet = hashMap.keySet();
Iterator<String> iterator = keySet.iterator();
while(iterator.hasNext())
{
String key = iterator.next();
String valus = hashMap.get(key);
System.out.println("key:" + key + "- value:" + valus);
}
//第二种
Set<Entry<String, String>> entrySet = hashMap.entrySet();
Iterator<Entry<String, String>> iterator1 = entrySet.iterator();
while (iterator.hasNext())
{
Entry<String, String> next = iterator1.next();
String key = next.getKey();
String value = next.getValue();
System.out.println("key:" + key + "- value:" + value);
}
//建议使用第一种
工具类：
Arrays 数组的工具类
Collections
Comparable //让实现这个接口的对象具有比较大小的能力
Compartor //比较者
File
抽象路径 C： + File.separator + java + File.separator ＋ ｄａｙ０１
绝对路径 E:\FA01
相对路径： ＼ｄａｙ０１
／／文件过滤器接口
class MyFilter implements FilenameFilter
{
public boolean isPPt(String name)
{
if(name.toLowerCase().endsWith(".ppt") || name.toLowerCase().endsWith(".pptx"))
{
return true;
}
return false;
}
@Override
public boolean accept(File dir, String name)
{
return isPPt(name);
}
}
字节流：
节点流：
ＦｉｌｅＩｎｐｕｔＳｔｒｅａｍ
ＦｉｌｅＯｕｔＰｕｔＳｔｒｅａｍ
注意： 一般都去读取图片、文件
处理流： 套在其他节点流或者处理流之上的流
缓存流 BufferedOutputStream （前提：节点流存在 只是性能上面有所提升）
字符流： 读文本
节点流
ＦｉｌｅＷｒｉｔｅｒ 字符输出流
ＦｉｌｅＲｅａｄｅｒ 字符输入流
处理流：
缓存流 BufferedReader 新增ｒｅａｄＬｉｎｅ（） 一次读取一行，如果到末尾就返回ｎｕｌｌ
BufferedWriter 新增 ｎｅｗＬｉｎｅ（） 换行