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;
}
}

JAVA学习第一阶段(2)的更多相关文章

  1. JAVA学习第一阶段(1)

    java入门第一阶段 1.在java中接受并保存用户输入的值: (1)import java.util.Scanner//引入包 (2)Scanner input=new Scanner (Syste ...

  2. java学习第一阶段——面向对象

    你聪明有人会说你心机重, 你靠的是努力有人会说你运气好, 你说自己天生乐观有人会说你虚假, 有时候, 你明明就是一杯白水, 却被人硬生生逼成了满肚子憋屈的碳酸饮料. 人一生要遇见太多人, 即使有些话字 ...

  3. Java学习第一天

    Java学习第一天 对于网络管理员或者黑客必须知道的八个cmd命令 详情请参考:http://www.2cto.com/os/201608/533964.html          nbtstat  ...

  4. Java 学习第一步-JDK安装和Java环境变量配置

    Java学习第一步——JDK安装及Java环境变量配置 [原文]  2014-05-30 9:09  Java SE  阿超  9046 views Java作为当下很主流的编程语言,学习Java的朋 ...

  5. 从.Net到Java学习第一篇——开篇

    以前我常说,公司用什么技术我就学什么.可是对于java,我曾经一度以为“学java是不可能的,这辈子不可能学java的.”结果,一遇到公司转java,我就不得不跑路了,于是乎,回头一看N家公司交过社保 ...

  6. 201671010140. 2016-2017-2 《Java程序设计》java学习第一周

       java学习第一周        本周是新学期的开端,也是新的学习进程的开端,第一次接触java这门课程,首先书本的厚度就给我一种无形的压力,这注定了,这门课程不会是轻松的,同时一种全新的学习方 ...

  7. java 初学者 第一阶段作业编程总结及心得体会

    0.前言 第一阶段java作业分为3次. 第一次作业是简单得一些语法和一些简单得逻辑思维,主要内容有求三角形是什么三角形的,还有就是求坐标点所在范围的,也涉及到了数字和字母的转换,总之相相当于是给ja ...

  8. JAVA EE 第一阶段考试

    在第一阶段中我们学习了Spring Struts2 Hibernate.虽然在外面的公司中,公司项目的框架中都不在使用Struts2了.他好像出现了不可修复的bug.但是在学校,依然还是要学习这个.在 ...

  9. day1:java学习第一天之eclipse安装

    选择开发语言的学习其实不用纠结,如果你说自己是做开发的,连最流行的开发语言都不会,好像说不过去,并且最流行也说明用的人多,优秀的人也会,自己要提高要多向优秀的人学习.想明白这点其实选择就好说了,再一个 ...

随机推荐

  1. what&#39;s deviceone

    DeviceOne技术介绍 一.     DeviceOne是什么 DeviceOne(以下简称Do)是一个移动开发的平台或技术,与之对等的是Android移动开发技术,iOS移动开发技术,Windo ...

  2. iOS MJRefresh设置MJRefreshStateNoMoreData状态图片

    MJRefresh地址 //  代码地址: https://github.com/CoderMJLee/MJRefresh//  代码地址: http://code4app.com/ios/%E5%B ...

  3. 《BI那点儿事》META DATA(元数据)

    关于数据仓库的数据,指在数据仓库建设过程中所产生的有关数据源定义,目标定义,转换规则等相关的关键数据.同时元数据还包含关于数据含义的商业信息,所有这些信息都应当妥善保存,并很好地管理.为数据仓库的发展 ...

  4. HTML5的拖拽时间 ondragstart

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...

  5. [windows phone开发]新生助手的开发过程与体会一

    功能需求分析: 1.  为到达学院的新生指路,给出所有路线,并给出必要提示: 2.  对学院建筑进行介绍: 3.  对学院周边环境(交通.购物.银行等)进行介绍: 4.  必要的应用设置 总体设计: ...

  6. flex布局的使用,纪念第一次开发手机网站

    一直专注于PC网站的开发,不曾接触手机网站,于今日机缘巧合也是公司业务需要,并在之前学习过flex的布局,于是一并实践.碰到的问题还是很多的,主要是谈谈flex布局. flex布局是css3里的内容, ...

  7. java中final小结

    fanal 修饰类,该变量一经赋值,就不能够再修改 修饰类,该类不能让子类继承. 修饰方法,该方法不能被子类重写(隐藏). fanal修饰类与方法的意义 1  某个类或方法实现上已经非常完善,不需要子 ...

  8. 论Android代码加固的意义和hook

    加固的意义 从安卓2.x版本起,加固技术就逐渐火了起来.最初,只有一些创业型公司涉及加固领域:随着安卓应用的逐渐升温,诸如阿里.腾讯.百度等大型互联网公司逐渐涉及该领域. 那么为什么要对APP进行加固 ...

  9. 精读《Scheduling in React》

    1. 引言 这次介绍的文章是 scheduling-in-react,简单来说就是 React 的调度系统,为了得到更顺滑的用户体验. 毕竟前端做到最后,都是体验优化,前端带给用户的价值核心就在于此. ...

  10. js中数组的map()方法

    map()方法返回一个新数组,数组中的元素为原始数组元素调用函数处理后的值 map()方法按照原是数组顺序以此处理元素 注意:map()不会对空数组进行检测 :不会改变原始的数组 实例: var nu ...