JAVA学习第一阶段（2）
21. ArrayList类和LinkList类
注意：add,contains,remove,retain(取交集) 都可以+all表示对集合的操作
ArrayList c = new ArrayList();//父类引用指向子类对象
ArrayList c1 = new ArrayList();
c.add("123");//添加任意类型的数据存入ArrayList对象
c.add(1);
Student s=new Student("Tom",18,'男');
Student s1=new Student("jim",30,'男');
c.add(s);
c1.add(s1);
System.out.println(c);
System.out.println(c.contains(s));//判断s是否是c中的存在的对象
System.out.println(c.get(2));//获取c中的第三个对象，如果索引越界会报错。
System.out.println(c.indexOf(s));//获取c中s对象的索引,如果不是c中的对象，哪怕值一样也是-1
System.out.println(c.remove("123"));//删除c中的s对象,可以直接写对象也可以写索引。
System.out.println(c.set(0,s1));//将c中下标为2的对象替换成s2
System.out.println(c.size());//集合c的长度
System.out.println(c.addAll(c1));//将c1中的元素加到c中
c.clear();//清空c中的元素
Object[] arr=c.toArray();//集合先会转换成Object类型的数组，可以通过循环遍历，然后再将object数组中的元素强行转换成想要的元素类型
for(int i=0;i<arr.length;i++){
Student s=(Student)arr[i];
}
//迭代器也是增强型的for循环的底层(foreach)
Iterator it = c.iterator();//获取迭代器，就是用来遍历
boolean b1=it.hasNext();//确定集合中是否有元素，有就返回true
while (it.hasNext()){
System.out.println(it.next());//类似每次取一位，指针向后移一位。
}
while(it.hasprevious()){//指针每次向前移动一位，逆向输出
System.out.println(it.previous());
}
/* LinkedList中的特有的方法*/
LinkedList l=new LinkedList();
l.addFirst("a");//每次都添加到第一位
l.addFirst("b");
l.addFirst("c");
System.out.println(l.getFirst());//获取第一位元素
System.out.println(l.getLast());//获取最后一位元素
System.out.println(l.removeLast());//除去最后一位元素
System.out.println(l.removeFirst());//除去第一位元素
例子：封装一个类用做其他类的功能块
public class Stack {
private LinkedList list=new LinkedList();
public void in(Object obj){
list.addLast(obj);
}
public Object out(){
return list.getFirst();
}
}
22.泛型(Generic)
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
好处在于：
1.编译时强类型检查；
2.无需手动进行类型转换；
3.可以实现复用，编写通用算法
注意：类，方法，接口也能声明泛型，表示该类该方法只能传入这种类型的参数
类型通配符一般是使用?代替具体的类型参数。例如List<?>在逻辑上是List<String>,List<Integer> 等所有List<具体类型实参>的父类。
泛型固定下边界：? super <E>
泛型固定上边界：? extends <E>
ArrayList<Stack>s=newArrayList<Stack>();//声明该集合对象只能存入Stack类的对象元素
Stack n=new Stack("xu");
s.add(n);
//s.add(12);//编译时强类型检查；
示例代码：
public static <E> void printArrays(E[] inputArray){
//建立一个泛型方法，声明传入的参数数组类型应该和方法类型一致
for(E s:inputArray){//声明该类型数组元素的类型
System.out.printf("%s",s);
System.out.print(' ');
}
System.out.println();
}
public static <T extends Comparable<T>> void sort (T[] input){
T temp;
for (int i=0;i<input.length-1;i++){
for (int j=0;j<input.length-1-i;j++){
if(input[j].compareTo(input[j+1])>0){
temp=input[j];
input[j]=input[j+1];
input[j+1]=temp;
}
}
}
for(T s:input){
System.out.printf("%s",s);
System.out.print(' ');
}
System.out.println(' ');
}
public static void getData(List<?> data) {
System.out.println("data :" + data.get(0));
}
public static void getUperNumber(List<? extends Number> data) {
System.out.println("data :" + data.get(0));
}
public static void main(String[] args) {
Integer[] intArray={1,2,3,4};
Double[] doubleArray={1.2,2.3,3.4};
String[] stringArray={"ss","rs","ls"};
// System.out.println("输出int型数组");
// printArrays(intArray);//传入相应参数数组，声明了泛型方法，应该能自动对传入的数组类型进行判断
// System.out.println("输出double数组");
// printArrays(doubleArray);
// System.out.println("输出String型数组");
// printArrays(stringArray);
System.out.println("对int型数组排序");
sort(intArray);
System.out.println("对double型进行排序");
sort(doubleArray);
System.out.println("对string型进行排序");
sort(stringArray);
List<String> name = new ArrayList<String>();
List<Integer> age = new ArrayList<Integer>();
List<Number> number = new ArrayList<Number>();
name.add("icon");
age.add(18);
number.add(314);
//getUperNumber(name);//1
getUperNumber(age);//2
getUperNumber(number);//3
}
注意：
1. 迭代器，for循环，增强for循环(三种循环中只有增强for循环不能被用来删除)
2. 可变参数方法：
public static void print(char...arr){//可变参数,输入的参数个数可以随便改
for (int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
3. Arrays中的asList()方法
String [] arr={"ss","bb","dd"};
List<String> s= Arrays.asList(arr);//数组转换成集合，基本数据类型转换成集合，会将整个数组当成一个对象
4.集合的嵌套
ArrayList<ArrayList <Stack>>s=new ArrayList<>();
ArrayList<Stack>S1=new ArrayList<>();
ArrayList<Stack>S2=new ArrayList<>();
S1.add(new Stack("XU"));
S1.add(new Stack("GG"));
S2.add(new Stack("MU"));
s.add(S1);
s.add(S2);
for (ArrayList<Stack> i:s) {
for (Stack name:i){
System.out.println(name);
}
}
23. HashSet类
Set集合的方法和collection方法一样，只是效果略不同
HashSet存储自定义对象必须要同时重写equals()和HashCode方法，才能保证元素唯一。只有equals()方法比较出来的是true还有hashcode()中的值相等，才会认作是同一个元素，否则，如果hashcode不同的话，集合中将会存储两个对象，如果只是equals()方法不同的话，HashSet会将两个元素储存到同一个地址，这样的话这个位置就必须要用链式结构来保存多个对象。
注意：(1)当程序将可变对象添加到HashSet之后，尽量不要修改该集合元素的实例变量，否则HashSet无法正确操作这些集合元素。
(2)LinkedHashSet类是HashSet的子类，按输入元素的顺序将元素保存到集合
例子：
HashSet s=new HashSet();
s.add('s');
s.add('a');
s.add('c');
System.out.println(s);
LinkedHashSet s1=new LinkedHashSet();
s1.add('s');
s1.add('a');
s1.add('c');
System.out.println(s1);
24. TreeSet类
TreeSet类中的元素是按一定的方法排序的，添加的元素应该是同一个类的对象，否则会有异常
25. 正则表达式
//在java的正则表达式中\\等于一个反斜杠，所以我们要表达反斜杠本身的含义要用\\\\，而要用相应的字符，应该用\\，比如\\b,\\s,\\w
// Pattern p=Pattern.compile(regex);//简单工厂方法创建一个正则表达式regex;
// Matcher m=p.matcher(context);//Matcher实例在这个给定的Pattern实例的模式控制下进行字符串的匹配工作。
/*Matcher类提供三个匹配操作方法,三个方法均返回boolean类型,当匹配到时返回true,没匹配到则返回false
1.matches()对整个字符串进行匹配,只有整个字符串都匹配了才返回true
2.lookingAt()对前面的字符串进行匹配,只有匹配到的字符串在最前面才返回true
3.find()对字符串进行匹配,匹配到的字符串可以在任何位置.
4.start()返回匹配到的子字符串在字符串中的索引位置.
end()返回匹配到的子字符串的最后一个字符在字符串中的索引位置.
group()返回匹配到的子字符串 */
Pattern p1= Pattern.compile("\\d+");
System.out.println("请输入信息");
Scanner Input=new Scanner(System.in);
String input=Input.nextLine();
Matcher m1=p1.matcher(input);
while (m1.find()){
System.out.println(m1.group());
26. Map类
Map<String,String> m=new HashMap<>();//创建一个HashMap集合key-value
m.put("1","xu");//将值传入
m.put("2","GG");
m.put("3","MU");
for (String key:m.keySet()) {//通过Map.keySet遍历key和value
System.out.println("该HashMap集合中的元素为"+key+"值为"+m.get(key));
}
for (Map.Entry<String, String> entry : m.entrySet()) {//通过Map.entrySet遍历key和value
System.out.println("key= " + entry.getKey() +
" and value= " + entry.getValue());
}
/*keySet()的速度比entrySet()慢了很多，
也就是keySet方式遍历Map的性能不如entrySet性能好
为了提高性能，以后多考虑用entrySet()方式来进行遍历。*/
注意：抽象类和接口的不同：
（1）抽象类可以有构造方法，接口中不能有构造方法。
（2）抽象类中可以有普通成员变量，接口中没有普通成员变量
（3）抽象类中可以包含静态方法，接口中不能包含静态方法
（4） 一个类可以实现多个接口，但只能继承一个抽象类。
（5）接口可以被多重实现，抽象类只能被单一继承
（6）如果抽象类实现接口，则可以把接口中方法映射到抽象类中作为抽象方法而不必实现，而在抽象类的子类中实现接口中方法
27. I/O流之file类
定义:file主要是用来储存文件的路径：
1.文件路径或者文件夹路径
2.绝对路径(固定的)和相对路径
3.文件和目录的抽象表示形式
具体代码：
import java.io.*;
public class FileTest {
public static void main(String[] args)throws IOException{
/*1.通过输入文件名路径的方式创建file对象
* 2.通过输入文件名路径及其子文件路径的方式创建file对象
* 3.通过file创建的file对象及其子文件路径的方式创建一个对象，
好处在于父文件路径可以调用file的方法*/
File file=new File("E:\\java-test-file\\src\\test1\\HelloWorld.java");
String parent="E:\\java-test-file\\src\\test1";
String child="HelloWorld.java";
File file1=new File(parent,child);
File fileparent=new File("E:\\java-test-file\\src\\test1");
String child1="HelloWorld.java";
File file2=new File(fileparent,child1);
/* 1.创建文件如果存在就不创建,这里会报错是因为我们调用这个方法所在的方法没有抛出异常
如果发现存在需要返回异常信息,所以要在方法后抛出IOException
2.创建文件夹，如果存在就不创建了
3.创建文件夹如果父类文件夹不存在可以帮你创建出来*/
file2.createNewFile();
File file3=new File("aaa");
file3.mkdir();
File file4=new File("bbb\\ccc");
file4.mkdirs();
/*把文件重命名为指定文件路径,如果重命名的两个文件是相同路径则为改名，
不是相同路径则会将原文件删除并且创建新名称的文件*/
File file5=new File("ddd");
file3.renameTo(file5);
//删除文件,注意如果要删除文件夹，文件夹其中不能有其他东西，java删除的文件不会出现在回收站
file4.delete();
/*file类的判断方法：
1.调用exist();方法判断该文件是否存在
2.判断是否是目录
3.判断是否是文件
4.判断是否可读,可写(windows系统中默认是所有文件可读)
5.判断是否隐藏*/
System.out.println(file2.exists());
System.out.println(file.isDirectory());
System.out.println(file1.isFile());
System.out.println(file2.canRead());
file2.setReadable(false);//设置为不可读
file3.setWritable(false);//设置为不可写
System.out.println(file3.canWrite());
System.out.println(file4.isHidden());
/*file类的获取方法
* 1.获取绝对路径
* 2.获取路径
* 3.获取名称
* 4.获取字节数长度
* 5.获取最后一次修改时间
* 6.获取指定目录下所有文件或文件夹的名称数组
* 7.获取指定目录下所有文件或文件夹的file数组*/
file1.getAbsolutePath();
file2.getPath();
file3.getName();
file4.length();
file5.lastModified();
file.list();
file.listFiles();
//实例：判断E盘下是否有.exe结尾的文件
File E=new File("E:\\");
String[] list=E.list();
int index=0;
for (String s:list) {
if(s.contains(".exe")){//这里可以直接endsWith()判断后缀
System.out.println(s);
index++;
}
}
System.out.println("共有"+index+"个");
//FileFilter过滤器，先定义一个类实现FilenameFilter接口，再重写类中的方法并调用
MyFilter myFilter = new MyFilter();
String[] ls = file.list(myFilter);
//收集file对象下的文件夹和文件，名字进入myFilter对象筛选所得字符串数组
for (String string : ls) {
System.out.println(string);
}
}
}
class MyFilter implements FilenameFilter {
@Override
public boolean accept(File dir, String name) {
if(name.endsWith("txt")){//文件名以txt结尾的文件
return true;
}else{
return false;
}
}
}
28.I/O流之输入输出流
主要分字节流(FileInputStream和FileOutputStream)和字符流(Writer和Reader)
使用前导入IO包中的类
使用时要进行IO异常处理
使用后释放资源
public static void main(String[] args) throws IOException{
/*
* 1.FileInputStream类(InputStream类的子类，可实例化)创建对象的时候，
* 如果没有创建，会报错
* 2.FileOutputStream类(OutputStream类的子类，可实例化)创建对象的时候，
* 如果没有创建帮你创建，如果有的话，每执行一次创建会清空对象的内容*/
//创建输入流对象，类似于插根管子到文件上，可以输入数据流
FileInputStream fls=new FileInputStream("C:\\Users\\xu-saozhu\\Desktop\\TP\\Test.mp4");
//以字节流的形式读取输入的文件流中的内容，所以出来的是一个数字,如果读取出来的是-1表示文件读取结束
//为了保证能完整读完所以读出的数据不用byte而是int（等于四个byte长度）,
// 这样才不会出现因为读到byte值为11111111的数据误以为是读取结束信号
//创建一个输出流对象，类似于创建一个文件到指定的目录下，
// 再向文件里写东西,每次执行都会清空该文件，续写在创建对象的第二个参数传true
FileOutputStream fls1=new FileOutputStream
("C:\\Users\\xu-saozhu\\Desktop\\TP\\copy.mp4");
//写了ASCII码对应的码表值，自动在文件里转换成字符
int x;
while ((x=fls.read())!=-1){//将Set.java中的文件复制到hello.java中
fls1.write(x);
}
fls.close();//关闭输入流
fls1.close();//关闭输出流
//以上方法只能单个字节传输，效率太低。通过创建字节数组一次性读完一次性写入，
//但是该方法不推荐使用，因为如果要读取大量数据的话可能会导致内存溢出，
// 比如读一个10G大的文件，内存都只有4G或者8G大，而且该数组也不是无限长的，只能存储100多M数据
byte[] arr=new byte[fls.available()];//创建字节数组长度和读取的文件一样
fls.read(arr);//将文件读取到字节数组中
fls1.write(arr);//将字节数组中数据写到文件中
//所以这里用一个固定自长的小数组，相当于夹子，数据相当于砖堆，数组大小相当于夹子大小，
// 如果夹子大则一次性搬的砖多，如果夹子小则搬得砖少
byte[] arr1=new byte[1024*8];
int len;
while ((len=fls.read(arr1))!=-1){
fls1.write(arr1,0,len);
}
fls.close();
fls1.close();
//缓冲区对象BufferedInputStream和BufferedOutputStream，相当于夹子长度是8192个字节(1024*8)
//效率高，因为缓冲区BufferInputStream和BufferOutputStream相当于在内存中操作，
// 而FileInputStream和FileOutputStream相当于是在硬盘中操作。
BufferedInputStream bis=new BufferedInputStream(fls);
BufferedOutputStream bos=new BufferedOutputStream(fls1);
int len1;
while ((len1=bis.read(arr1))!=-1){
bos.write(arr1,0,len1);
}
//只需要关包装后的流就行
bis.close();
bos.close();
}
/*close方法：具有刷新功能，关闭流之前会刷新一次缓冲区，将缓冲区的字节全部刷新到文件上再关闭
flush方法：和close类似，但是close刷新完后不能写入了，flush方法刷新完可以继续写*/
FileInputStream is=new FileInputStream("C:\\Users\\xu-saozhu\\Desktop\\TP\\Test.mp4");
FileOutputStream os=new FileOutputStream("C:\\Users\\xu-saozhu\\Desktop\\TP\\copy.mp4");
BufferedInputStream bis=new BufferedInputStream(is);
BufferedOutputStream bos=new BufferedOutputStream (os);
int b;
while ((b=bis.read())!=-1){
bos.write(b);
}
bis.close();
bos.close();
//字节流读中文 String(arr,0,length);
// 字节流写中文：String.getByte();
//流处理标准异常代码的方法
//可以自动关闭流，因为这几个类都实现了AutoCloseable方法
try( FileInputStream is1=new FileInputStream("C:\\Users\\xu-saozhu\\Desktop\\TP\\Test.mp4");
FileOutputStream os1=new FileOutputStream("C:\\Users\\xu-saozhu\\Desktop\\TP\\copy.mp4");
BufferedInputStream bis1=new BufferedInputStream(is1);
BufferedOutputStream bos1=new BufferedOutputStream (os1);
){
int b1;
while ((b1=bis1.read())!=-1){
bos1.write(b1^123);//异或一个数表示加密，再次异或就相当于是它本身，从而实现加密效果
//解密过程相当于调用同一个函数只是写入的文件变成了读入的文件
}
}
29. I/O流之字符流
public static void main(String[] args) throws IOException{
/*
* 字符流(一般在只读或者只写的时候用)
* 不能用来拷贝非纯文本文件，因为在将字节转换成字符过程中
* 会有的字节找不到能转换的字符就用？代替，再转为字节的时候？转换就会影响数据的准确性
* 1.定义:直接读写字符的流
* 2.原理:读取字节数据转换成字符再显示，写入先将字符转换成字节数据再储存进文件.
* 码表中中文字符都是两个字节，其中第一个字节一定为负数，所以只要检测到字节是负数，就会两个字节一起读*/
//FileReader类似于FileInputStream，其中的read方法返回int型的数据，以单个字符长度
//读取结束返回-1
FileReader fr=new FileReader("E:\\java-test-file\\src\\test1\\test.txt");
FileWriter fw=new FileWriter("E:\\java-test-file\\src\\test1\\copy.txt");
FileInputStream fr1=new FileInputStream("E:\\java-test-file\\src\\test1\\test.txt");
FileOutputStream fw1=new FileOutputStream("E:\\java-test-file\\src\\test1\\copy.txt");
BufferedReader br=new BufferedReader(fr);//缓冲区大小为16k
BufferedWriter bw=new BufferedWriter(fw);
InputStreamReader ir=new InputStreamReader(fr1,"utf-8");//通过指定的码表写入或者读取字符
OutputStreamWriter iw=new OutputStreamWriter(fw1,"utf-8");
//LineNumberReader继承自BufferedReader并多下面两个方法
//获取行号：getLineNumber()
//设置行号：setLineNumber()
int x;
while ((x=br.read())!=-1){
bw.write(x);
}
String line;//readLine()整行读取，遇到回车或者换行符则停止
while ((line=br.readLine())!=null){
bw.write(line);//将每行写入
bw.newLine();//换行，可以跨平台，比用\r\n好
}
int len;
char[] arr=new char[1024*8];//字符数组大小为16k
while ((len=fr.read(arr))!=-1){//以字符数组的形式读取
fw.write(arr,0,len);
}
//fw.write("大家好，我系渣渣辉");
//不关流，内容写在2K的缓冲区里
br.close();
bw.close();
}
30. I/O流之序列流，内存输出流，随机访问流，对象操作流,数据输入输出流
/*
* 序列流可以将多个字节输入流整合成一个*/
FileInputStream fi1=new FileInputStream("test1.txt");
FileInputStream fi2=new FileInputStream("test2.txt");
FileInputStream fi3=new FileInputStream("test3.txt");
// SequenceInputStream sis=new SequenceInputStream(fi1,fi2);//整合两个输入流
Vector<FileInputStream> v=new Vector<>();//将流对象都放进容器
v.add(fi1);
v.add(fi2);
v.add(fi3);
Enumeration<FileInputStream> en=v.elements();
SequenceInputStream sis=new SequenceInputStream(en);//将多个流整合
FileOutputStream fo=new FileOutputStream("test4.txt");
int b;
while ((b=sis.read())!=-1){
fo.write(b);
}
sis.close();
fo.close();
//内存输出流:向内存中写数据，把内存当成缓冲区，最后一次性输出
ByteArrayOutputStream baos=new ByteArrayOutputStream();
//内存中创建字节数组，长度可变(实际是数组存爆了就会直接建立新的更长的数组)
while ((b=sis.read())!=-1){
baos.write(b);//将数据写入内存输出流中
}
// byte[] byt=baos.toByteArray();//内存输出流的数据储存在字节数组中
// System.out.println(new String(byt));
System.out.println(baos.toString());
baos.close();//关闭无效，内存中创建，使用完会自动丢弃
//随机访问流
RandomAccessFile raf=new RandomAccessFile("test1.txt","rw");
raf.seek(10);//设置指针，在规定的位置写
raf.write(98);//向文件里写入东西
int x;
x=raf.read();
System.out.println(x);
raf.close();
//对象操作流
Student stu1=new Student("张三",23,'男');
Student stu2=new Student("李四",24,'男');
FileInputStream fis=new FileInputStream("test1.txt");
FileOutputStream fos=new FileOutputStream("test1.txt");
ObjectInputStream ois=new ObjectInputStream(fis);
ObjectOutputStream obj=new ObjectOutputStream(fos);
obj.writeObject(stu1);
obj.writeObject(stu2);
Student stu3=(Student) ois.readObject();
Student stu4=(Student) ois.readObject();//这里要加一个类找不到的异常
//这里很容易出现因为不知道要输出多少个对象而多输出报错，为了防止这样的情况发生，
// 我们一般会用ArrayList集合去储存对象再将输入输出到文件中
obj.close();
//数据输入输出流
可以按照基本数据类型大小来读写数据，如readInt(),writeInt()...
DataInputStream和DataOutputStream
31. I/O流之打印流，标准输入输出流
//打印流
PrintStream ps= System.out;//获得标准打印字节流
ps.println(97);//相当于System.out.println,默认调用toString方法转换成字符串查找
ps.write(97);//相当于查找码表打印出的是a
PrintWriter pw=new PrintWriter("test.txt");//打印字符流
pw.println(97);//printwriter有自动刷出功能但是只针对println方法
pw.write(97);
//标准输入输出流
InputStream is=System.in;//一个程序中只能有一个标准输入流(即如果关闭标准输入流，后面再创建输入流也没用)
// 这里没有关联某个文件，所以可以不用关闭流
is.read();
//如果没有改变标准输入输出流则会默认在键盘上读取或者写入(改变之后需要关闭流操作)
System.setIn(new FileInputStream("test1.txt"));//改变标准输入流
System.setOut(new PrintStream("test2.txt"));//改变标准输出流
InputStream is1=System.in;
is1.read();
PrintStream ps=System.out;
32. Properties
/*Properties是HashTable类的子类，一般用于配置文件，基本不修改的。
* 表示一个持久的属性集，可保存在流中
* 或者从流中加载，属性列表中每个键
* 及其对应值都是一个字符串，一般做map集合使用
* */
Properties prop=new Properties();
prop.setProperty("name","张三");
prop.setProperty("tel","18879767702");
//取出prop的键值存入一个枚举的集合中
Enumeration<String> en=(Enumeration<String>)prop.propertyNames();
while (en.hasMoreElements()){
String key=en.nextElement();
String value=(String) prop.get(key);
System.out.println(key+"="+value);
}
//load方法和store方法类似于I/O流里的读取和写入
prop.load(new FileInputStream("test.txt"));
//存取顺序不一致，底层是hash
System.out.println("读取后"+prop);
prop.store(new FileOutputStream("test.txt"),"这里放对前面文件描述");
33.JDBC
JDBC全称为Java Data Base Connectivity(java数据库连接)，可以为多种数据库提供统一的访问。
package DataBase;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
//该类用于连接数据库
public class DBUtil {
private static final String URL="jdbc:mysql://127.0.0.1:3306/jdbc_test";
private static final String ROOT="root";
private static final String PASSWORD="";
private static Connection con=null;
static {
try {
//1.加载驱动程序
Class.forName("com.mysql.jdbc.Driver");
//2.获取数据库连接
con= DriverManager.getConnection(URL,ROOT,PASSWORD);
//通过数据库连接操作数据，实现增删改查
}
catch (ClassNotFoundException e){//没找到驱动程序类，捕获异常
// 将完整的错误信息写入日志
e.printStackTrace();
} catch (SQLException e){
e.printStackTrace();
}
}
public static Connection getConnection(){
return con;
}
}
package Dao;
import DataBase.DBUtil;
import model.Student;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
public class StudentDao {
public void add(String name,int age,String sex) throws Exception{
Connection con=DBUtil.getConnection();
Statement sta=con.createStatement();
String ss="insert into Student values ("+name+","+age+","+sex+");";
StudentDao sd=new StudentDao();
List<Student> S=sd.query();
for (Student s: S) {
System.out.println(s.getName()+" "+s.getAge()+" "+s.getSex());
}
}
public List<Student> query() throws SQLException {
Connection con= DBUtil.getConnection();
Statement sta=con.createStatement();//创建一个 Statement 对象来将 SQL 语句发送到数据库
ResultSet rs=sta.executeQuery("select * from Student");//查询sql语句，结果返回rs中
List<Student> ss=new ArrayList<Student>();//创建一个arraylist数组集合，元素为student对象
Student s1=null;//创建student对象
while (rs.next()){//结果中的每个元素按查找字符顺序写入student类中，再将student类写入集合中
s1=new Student();
s1.setName(rs.getString("name"));
s1.setAge(rs.getInt("age"));
s1.setSex(rs.getString("sex"));
ss.add(s1);
}
return ss;
}
}
