JavaWeb整合(包括各种实用小知识点)

字符下标Intindexof("");获取""中字符的下标:Stringstr="iloveyou";System.out.println(str.indexOf("l"));//2index前加last可以获取字符最后一次出现的坐标intindexof("",int);获取int+1之后字符的下标(含头不含尾)Stringstr="iloveyou";System.out.println(str.indexOf("o",3+1));//8intlength();获取字符串长度Stringstr="Ilovejava";System.out.println(str.length());substring(int,int);截取字符串中一段字符(含头不含尾)Stringstr="IcanspeckEnglishn";Stringsub=str.substring(3,8);System.out.println(sub);//anspstr.trim();去除字符串中的空白,字符中的空白不去Stringstr="java";Stringa=str.trim();System.out.println(a);//javacharAt(int);获取指定下标字符Stringstr="Iloveyou";chara=str.charAt(2);System.out.println(a);//lbooleanstratsWith(str);/endWith(str);判断是否以给定字符开头或结束Stringstr="ILOVEyou";System.out.println(str.startsWith("I"));//trueSystem.out.println(str.endsWith("U"));//flasestr.toUpperCase();/str.toLowerCase();将字符英文大/小写Stringstr="ILOVEyou";Stringa=str.toUpperCase();//ILOVEYOUStringb=str.toLowerCase();//iloveyou基本类型转与字符串转换String.valueof(str);基本类型转换为字符串inta=123;Stringb=String.valueOf(a);System.out.println(b+2);//1232System.out.println(a+2);//125parse(Stringstr);将字符串转换为基本类型Stringstr="123.123";doublei=Double.parseDouble(str);System.out.println(i+1);//124.123System.out.println(str+1);//123.1231字符串封装StringBuilder封装可变字符串 对象创建后可调用方法来对封装的字符串进行操作Stringstr——>StringBuilderbuilder字符串封装Stringstr="IloveYOU";StringBuilderbuilder=newStringBuilder(str);StringBuilderbuilder——>Stringstr拆封Stringstr=builder.toString();System.out.println(str);将给定字符串追加到当前字符串末尾 builder.append("");给定字符串替换start-end内字符串 builder.replace(start,end,"");删除当前字符串指定范围内字符 builder.delete(start,end);将给定字符串插入到指定位置 builder.insert(int,"");反转字符串 builder.reverse();正则表达式(regex)booleanstr.matches(regex);根据()中的正则表达式判断str是否满足Stringc="[0-9a-zA-Z_]+@[0-9a-zA-Z_]+\\.[a-zA-Z]+";Stringi="329939786@";booleana=i.matches(c);System.out.println(a);//trueString[]split(Stringregex);将当前字符串中满足给定正则表达式的部分进行拆分,返回所有剩下的部分Stringstr="aaa123bbb123cc456dd789eee";String[]d=str.split("[0-9]");for(inti=0;i<d.length;i++){System.out.println(d[i]);//aaabbbcccdddeeeStringstr.replaceAll("regex","replace");将字符串中满足正则表达式的字符替换为指定内容Stringstr="aaa123bbb123cc456dd789eee";Stringa=str.replaceAll("[0-9]","OOO");System.out.println(a);//aaaOOObbbOOOcccOOOdddOOOeee基本类型与面向对象(引用类型)转换基本类型——>面向对象(引用类型)Doublei=Double.valueOf(1.1);Integera=Integer.valueOf(3);面向对象(引用类型)——>基本类型转换为面向对象的可以以任何基本类型返回intt=Value();//以int形式返回doublea=i.doubleValue();//以double形式返回byteb=i.byteValue();//以byte形式返回MAX_VALUE/MIN_VALUE包装类对应基本类型的最大值/最小值intimax=Integer.MAX_VALUE;intimin=Integer.MAX_VALUE;System.out.println(imax+","+imin);//获取intger的max与minlongbytedoule都可以Date:过时,仅用于表示当前时间要导包importDatedate=newDate();//获取当前系统时间System.out.println(date);//println方法输出的是toString//WedApr0618:04:08CST2016longgetTime()获取Date内部维护的long值,即:1970年到现在时间之间经过的毫秒值.longtime=date.getTime();System.out.println(time);voidsetTime(longtime)将给定的long值设置到Date中,使其表示该时间.time+=1000*60*60*24;//当前系统时间加一天date.setTime(time);System.out.println(date);String与Date互相转换SimpleDateFormatDate——>String 时间到字符串将给定的Date表示的时间按照给定的日期格式进行转换. 时间格式Datedate=newDate();(日期构造)SimpleDateFormatsdf=newSimpleDateFormat("yyyy-MM-ddHH:mm:ss");Stringstr=sdf.format(date);System.out.println(str)//2016-04-0618:09:14String——>Date 字符串到时间Stringstr="2008-05-0620:30:50";与str匹配的日期格式SimpleDateFormatsdf=newSimpleDateFormat("yyyy-MM-ddHH:mm:ss");Datedate=sdf.parse(str);System.out.println(date);longtimee=System.currentTimeMillis(); long类型的当前系统时间Timestamptime=newTimestamp(timee); 创建时间戳Calendar与Date互相转换Calendar:操控,修改的一个抽象类,要对时间进行操作,需要使用该类要导包importjava.util.Calendar;转换都是Calendar提供的方法.Calendarcalendar=Calendar.getInstance();//获得所在地区时间Calendar——>DateDatedate=calendar.getTime();System.out.println(date);Calendar提供了方法:DategetTime()该方法会将其表示的时间以Date类型返回.Date——>Calendarcalendar.setTime(date);System.out.println(calendar);Calendar提供了方法:voidsetTime(Datedate)该方法会使当前Calendar表示给定的Date所表示的时间.使用Calendar修改时间日期Calendar提供了对指定时间分量(时间单位)设置值的方法:voidset(intfield,intvalue)intfield:日期(day/month/year)intvalue:与field对应的数值Calendarcalendar=Calendar.getInstance();calendar.set(Calendar.YEAR,2008);calendar.set(Calendar.MONTH,7);calendar.set(Calendar.DAY_OF_MONTH,8);calendar.set(Calendar.HOUR_OF_DAY,20);calendar.set(Calendar.MINUTE,8);calendar.set(Calendar.SECOND,8);System.out.println(calendar.getTime());//WedAug0620:08:08CST2008month月份是从0开始,即1月为0,12月为11.dayofmonth月中天,几号.dayofweek周几,周天是1,周六是7.dayofyear年中天.hour12小时制,没有am/pmhourofday24小时制1.intget(intfield)获取指定时间分量所对应的值Calendarcalendar=Calendar.getInstance();intyear=calendar.get(Calendar.YEAR);intmonth=calendar.get(Calendar.MONTH)+1;//月份是从0开始的,转换为int时需要+1intday=calendar.get(Calendar.DAY_OF_MONTH);System.out.println(year+"-"+month+"-"+day);intdays=calendar.get(Calendar.DAY_OF_YEAR);System.out.println("今天是今年的第"+days+"天");intweek=calendar.get(Calendar.DAY_OF_WEEK);System.out.println("今天是周"+(week==1?7:week-1));char[]weeks={'日','一','二','三','四','五','六'};System.out.println("今天是周"+weeks[week-1]);周中天1是周天其余为week-1遂可以用三目也可以用数组2.calendar.getActualMaximum获取某个时间分量所允许的最大值Calendarcalendar=Calendar.getInstance();calendar.set(Calendar.YEAR,2016);//输入年份intday=calendar.getActualMaximum(Calendar.DAY_OF_YEAR);System.out.println(day);//366查看月/年中有多少天可以用该方法3.voidadd(intfield,intvalue)计算时间Calendarcalendar=Calendar.getInstance();calendar.add(Calendar.YEAR,3);//加三年calendar.add(Calendar.MONDAY,4);//加四个月calendar.add(Calendar.DAY_OF_YEAR,25);//加25天calendar.add(Calendar.DAY_OF_YEAR,-15);//减15天MONTHDay时分秒都可以计算,正为加,负为减Day要用年中天,DAY_OF_YEARCollection(接口)集合有两个子接口:List可重复集合set不可重复集合(不常用)Collectionc=newArrayList();使用c.add()来添加元素c.add("你");1.intsize()获得当前集合元素数量intsize=c.size();System.out.println(size);2.booleanisEmpty()判断集合是否为空集合booleane=c.isEmpty();System.out.println(c.isEmpty());判断集合是否包含元素,不包含为true.有元素为false没有元素为true3.voidclear()清空集合所有元素c.clear();4.booleancontains(Ee)判断当前集合是否包含给定元素Collectionc=newArrayList();c.add(1);c.add(2);c.add(3);c.add(3);System.out.println(c);//[1,2,3,3]inta=3;System.out.println(c.contains(a));//是否包含a元素,true判断集合是否包含给定元素,是依靠元素自身equals的比较结果5.booleanremove()删除集合中给定元素System.out.println(c.remove(a));//删除a元素一次,trueSystem.out.println(c);//[1,2,3]同样依据equals比较结果,从第一个元素开始比,发现即删除,只会删除一次集合中加入的元素都是引用类型,存入的是地址,与对象创建时的引用指向同一个对象,一改都改.addAll把一个集合所有元素放入指定集合Collectionc1=newArrayList();c1.add(1);c1.add(2);c1.add(3);Collectionc2=newArrayList();c2.add(4);c2.add(5);c1.addAll(c2);//c2放入c1中System.out.println(c1);//[1,2,3,4,5]booleanaddAll(Collectionc);booleana=c1.addAll(c2);System.out.println(a);将给定的集合中的元素存入到当前结合中当执行完毕后,当前集合元素发生了改变则返回true.booleancontainsAll(Collectionc);判断当前集合是否包含指定集合所有元素Collectionc3=newArrayList();c3.add(2);c3.add(5);System.out.println(c1.containsAll(c3));//true包含依然是依据元素自身equals比较的结果removeAll();删除c1中c3的所有元素System.out.println(c1);//[1,2,3,4,5]c1.removeAll(c3);System.out.println(c1);//[1,3,4]删除只针对c1,若c1中没有c3的元素则不删除迭代器Iterator遍历集合遍历集合需要遵循步骤:问,取,删 其中删除不是必须操作Collectionc=newArrayList();

c.add("one");c.add("#");c.add("two");c.add("#");c.add("three");c.add("#");Iteratorit=c.iterator();//Iteratoriterator,获取遍历当前集合的迭代器while(it.hasNext()){//判断是否有元素Stringstr=(String)it.next();//将元素取出,由于取出为object类,遂强转为StringSystem.out.println(str);//输出单个元素if("#".equals(str)){it.remove()//从集合中删除通过next()方法取出的元素} }System.out.println(c);//one,two,three迭代器中删除元素不要使用集合本身的str.remove要使用迭代器删除方法删除元素c.remove增强型for循环1.5后可用不代替for循环的工作1.for(接受遍历数组元素的变量类型变量名:需遍历的数组) 数组String[]array={"one","two","three","four","five"};for(Stringstr:array){ System.out.println(str);//one,two,three,four,five }2.for(object变量名:集合名) 集合for(Objecto:c){ Stringstr=(String)o;//因为是Object遂需强转 System.out.println(str);}增删元素仍遵循迭代器的要求泛型在定义的方法/类的变量名后加个<>可以设置泛型JDK1.5之后 泛型在集合中的应用:(可以声明多个且可以不同类型) 1.在集合中使用泛型是用来说明集合中的元素类型. 2.这样可以规定集合只能是存放该类型元素.若不指定泛型类型,则默认为object,可以先泛型再在for循环中遍历集合,这样无需强转Collection<String> c=newArrayList<String>();使用迭代器时,迭代器的泛型应与集合一致Iterator<String>it=c.iterator();List接口继承collectoinList集合是可重复集,并且有序,特点是可以通过下标操作元素两个常用实现类:ArrayList动态数组LinkedList链表ArrayList动态数组List<String>list=newArrayList<String>();list.add("one");list.add("two");list.add("three");list.add("four");1.Eget(intindex)获取指定下标对应的元素System.out.println(list.get(1));//two2.遍历List集合for(inti=0;i<list.size();i++){//size()元素数量用来判断集合长度 System.out.println(list.get(i));3.Eset(intindex,Ee)替换元素操作将给定元素设置到指定位置上,返回值为原位置上的旧元素Stringold=list.set(1,"2");//把下标为1的two替换为2System.out.println(list);//one,2,three,for4.voidadd(intindex,Ee)将给定的元素插入到指定位置list.add(2,"2");System.out.println(list);//[one,two,2,three,four]5.Eremove(intindex)删除指定位置的元素,有返回值Stringold=list.remove(2);System.out.println(old);//输出删除的元素6.ListsubList(intstart,intend)获取指定范围子集List<String>sub=list.subList(0,3);//含头不含尾 System.out.println(sub);//[one,two,three]对获取的子集进行修改,原集合元素也一同改变集合转数组collection提供了toArray方法,其自己,set,list都可用String[]array=c.toArray(newString[c.size()]);String[]中的长度可:1.小于集合长度,若小于系统则提供一个符合长度要求的2.可大于集合长度,多余空白元素值为null建议新建数组长度为集合长度,即newString[c.size()]Collection<String>c=newArrayList<String>();c.add("one");c.add("two");c.add("three");String[]array=c.toArray(newString[c.size()]);System.out.println(array.length);for(Stringstr:array){ System.out.println(str);//one,\ntwo,\nthree}数组转集合只能转为List,因为Set不可重复arrays.asList()方法String[]array={"one","two","thrre","four"}; List<String>list=Arrays.asList(array); System.out.println(list);通过数组转换的集合,对集合元素修改就是对数组元素修改数组转换的集合不能添加新元素是集合的工具类,提供了便于操作集合的相关功能方法1.Collection.sort(Listlist)该方法会对集合进行自然排序(从小到大)List<Integer>list=newArrayList<Integer>();for(inti=0;i<10;i++){ list.add((int)(Math.random()*100));}Collections.sort(list);System.out.println(list);//数值排列由小到大2.比较器classmyComparatorimplementsComparator<String>{ publicintcompare(Stringo1,Stringo2){ returno1.length()-o2.length(); }}o1-o2大于0那么o1大队列java.util.Queue常用实现类1.创建队列Queue<String>queue=newLinkedList<String>();2.booleanoffer(Ee) 向队尾追加元素queue.offer("one");queue.offer("two");queue.offer("three");queue.offer("four");3.Epoll()获取队首元素,当获取后该元素即从队列中删除,该方法是出队操作Stringstr=queue.poll();System.out.println(str);//oneSystem.out.println(queue);//two,three.four4.Epeek()引用队首元素,与poll方法不同.虽然可以获取队首元素,但是不做出队操作System.out.println(queue.peek());//oneSystem.out.println(queue);//one,two,three.four5.遍历队列while(queue.size()>0){ System.out.println(queue.poll());}Map—查找表一.创建查找表Map<String,Integer>map=newHashMap<String,Integer>();1.Vput(K,V)将给定的key-value对存入Map中 键值对map.put("语文",98);map.put("数学",95);map.put("英语",85);Map要求key不允许重复(依靠key元素equals比较的结果判定是否重复)若给定的key的Map中已经存在,则是替换value操作,那么被替换的value会被返回.2.Vget(key)获取当前Map中指定的key所对应的valueSystem.out.println(map.get("语文"));//98若给定的key在Map中不存在,则返回值为null3.booleancontainsKey(key)判断当前Map是否包含指定kye4.booleancontainsValue(value)判断当前Map是否包含指定valueSystem.out.println(map.containsKey("语文"));//trueSystem.out.println(map.containsValue(5));//false5.map.vlaues()将values的值存为collection集合6.map.remove(key)删除指定key所对应的键值对.返回值为对应的value二.遍历Map遍历key与键值对都是set1.Set<>map.keySet()遍历keySet<String>set=map.keySet();for(Stringkey:set){ System.out.println(key);}2.Set<Entry>entrySet()遍历键值对Set<Entry<String,Integer>>entry=map.entrySet();for(Entry<String,Integer>e:entry){ System.out.println(e.getKey()+":"+e.getValue());}Entry十一个内部类,将kye-value存入其中,遂需要泛型Set泛型为Entry3.Collection<V>values()遍历所有valueCollection<Integer>c=map.values();for(Integera:c){ System.out.println(a);}例子中vlaues为integer类型,遂泛型为该类型File-文件/目录操作一.获取文件/目录Filefile=newFile("."+File.separator+"demo.txt");""中为文件路径,建议使用相对路径,File.separator转意为/1.file.getname()获取名字2.file.length()获取文件长度(字节)3.file.isFile()判断是否为文件(.txt.doc之类)4.file.isDir()判断是否为目录(文件夹)二.使用File创建一个文件1.file.exists()判断File表示的文件或目录是否真实存在2.file.createNewFile()使用File创建一个文件3.file.delete()删除文件三.使用File创建一个目录1.file.mkdir()使用File创建一个目录2.file.delete()删除目录(只有空目录才可以删)3.file.mkdirs()使用File创建多层目录(自动创建父目录)4.获取一个目录下所有子项File[]subs=file.listFiles();for(Filesub:subs){}使用listFiles()获取目录中所有子项,存到数组subs后遍历,用sub表示每一个元素5.删除给定的File对象表示的文件或目录publicstaticvoiddelete(Filefile){ if(!file.isFile()){//判断是否为文件 File[]subs=file.listFiles(); for(Filesub:subs){ delete(sub);//自己调自己的方法递归 System.out.println("删除"+sub.getName()); } } file.delete(); }四.过滤器可自定义要求过滤FileclassMyFilterimplementsFileFilter{/***过滤条件:以"."名字开头*/ @Override publicbooleanaccept(Filefile){ Stringname=file.getName(); returnname.startsWith("."); }}思路拓展使用递归输出1+2+3……100的和publicstaticvoidmax(inti,inta){ if(a<101){ i+=a; a++; System.out.println(i); max(i,a); }RandomAccessFile读写文件数据RandomAccessFile:有两种创建模式:"r":只读模式,进对文件数据做读取操作"rw":读写模式,可以对文件数据读写一.创建RandomAccessFileRandomAccessFileraf=newRandomAccessFile("text.dat","rw");text.dat处可以写字符串地址,也可以方File对象1.voidwrite()一次写出一个字节,写出的是该int值对应的2进制中的"低八位"2.intread()读取一个字节,并以int形式返回,读到-1则到文件末尾3.复制RandomAccessFileborn=newRandomAccessFile("born","r");RandomAccessFilecopy=newRandomAccessFile("born.copy","rw");intd;while((d=raf.read())!=-1){//读到-1为文件末尾copy.write(d);//将读到的字节写入到copy}二.写入字符串RandomAccessFileraf=newRandomAccessFile("raf.txt","rw"); Stringstr="赤道以北,二滚最美"; /* *以当前系统默认的字符集将字符串转换为字节 *windows:GBK *linux:UTF-8""中可以指定字符集 ""中可以指定字符集 byte[]data=str.getBytes("GBK"); System.out.println(data.length); /* *voidwrite(byte[]data) *一次性将给定的字节数组中的所有字节写入到文件中 */ raf.write(data); raf.close();三.读取字符串/**intread(byte[]data)*一次性尝试读取给定字节长度的字节量,并且将读取的字节顺序的存入到这个数组中,*返回值为实际读取到的字节量*/ RandomAccessFileraf=newRandomAccessFile("raf.txt","r"); byte[]data=newbyte[100]; intlen=raf.read(data); System.out.println(len+"个字节"); //将字节数组指定部分按照指定字符集转换为字符串 Stringstr=newString(data,0,len,"GBK"); System.out.println(str); raf.close();四.RandomAccessFile是基于指针的读写操作1.longgetFilePointer()获取指针当前位置2.voidseek()将指针调到指定位置输入/输出流都有节点流(低级流)与处理流(高级流)一.创建文件字节流对象1.写FileOutputStreamfos=newFileOutputStream("fos.txt");Stringstr="二滚最美";byte[]data=str.getBytes();fos.write(data);System.out.println("over");fos.close();默认创建出来的FOS是覆盖操作,即:当创建好该流针对某文件进行写操作前,流会将该文件所有数据删除,只有本次通过该流写出的数据会存于该文件中.fos的追加写模式FileOutputStreamfos=newFileOutputStream("fos.txt",true);为true再次写入即在末尾添加2.读FileInputStreamfis=newFileInputStream("fos.txt");byte[]data=newbyte[100];intlen=fis.read(data);Stringstr=newString(data,0,len);System.out.println(str);fis.close();二.创建节点流高级流对象1.缓冲流读:BufferedInputStream缓冲读入,需要close()写:BufferedOutputStreamFileOutputStreamfos=newFileOutputStream("bos.txt");BufferedOutputStreambos=newBufferedOutputStream(fos);bos.write("二滚".getBytes());//Stringstr="二滚"byte[]data=str.getbytes()/**强制将缓冲区内容写出,无论缓冲区是否装满*bos.coles()中内置一次flush();*/bos.flush();2.对象流对象序列化:调用writeObject方法后,首先将p对象转换为了一组字节,将将对象转换为一组字节的过程.持久化:将这组字节通过fos写入到文件中的过程.FileOutputStreamfos=newFileOutputStream("person.obj");ObjectOutputStreamoos=newObjectOutputStream(fos);oos.writeObject(p);//p是类对象System.out.println("over");oos.close();对象反序列化:将一组字节还原会对象的过程FileInputStreamfis=newFileInputStream("person.obj");ObjectInputStreamois=newObjectInputStream(fis);/**将一组字节还原会对象的过程称为:*对象反序列化*/Personp=(Person)ois.readObject();System.out.println(p);ois.close();3.字符流Reader字符输入流父类writer字符输出流父类4.转换流InputStreamReader:字符输入流OutputStreamWriter:字符输出流都可以按照指定字符集进行读取或写出缓冲字符输出流(按行输出)1.针对文件写出操作PrintWriter(Filefile/StringPath,这里可加字符集);PrintWriterpw=newPrintWriter("pw.txt");pw.println("啊哈哈");pw.colse();QQ发送PrintWriter可以直接处理字节流,也可以处理字符流但是直接处理字节流不可以指定字符集FileOutputStreamfos=newFileOutputStream("pw1.txt");PrintWriterpw=newPrintWriter(fos);//直接处理字节流,这里不能指定字符集若想指定字符集可在中间插入OutputStreamWrite方法FileOutputStreamfos=newFileOutputStream("pw1.txt");OutputStreamWriterosw=newOutputStreamWriter(fos,"GBK");PrintWriterpw=newPrintWriter(osw);2.自动行刷新PrintWriter处理流时可自动刷新PrintWriterpw=newPrintWriter(fos,true);pw.println("你好");当创建pw时第一个参数为流时,就支持第二个参数,该参数是一个boolean值,若为true则pw具有自动行刷新.自动行刷新写在println方法中,手动换行并不会刷新缓冲字符输入流(按行输入)1.BufferedReader缓冲字符输入流,可以按行读取字符串,只能读取字符流FileInputStreamfis=newFileInputStream("src"+File.separator+ "day08"+File.separator+"BRDemo.java");//读取字节流InputStreamReaderisr=newInputStreamReader(fis);//字节流——>字符流BufferedReaderbr=newBufferedReader(isr);//字符流按行读取QQ接收InputStreamReader(fis,"指定字符集")BufferedReader提供方法:StringreadLine()将接收的字符串按行读取Stringlen;while((len=br.readLine())!=null){ System.out.println(len);}该方法会连续读取若干字节,直到读取到换行符为止,然后将换行符之前的所有字符组成一个字符串后返回,但是返回的字符串不含有最后的换行符.当读取到文件末尾,返回值为null.异常处理JAVA异常结构中定义有Throwable类,其有两个子类:Exception:常见的各种异常.Error:java运行环境错误,虚拟机错误.1.try——catch1.JVM运行过程中出现异常,都会实例化一个该异常实例并抛出,然后检查该异常是否可以被捕获,若没有被true包围,则会将该异常抛到方法之外.2.catch可以包含多个,来分别捕获try中出现的不同异常来进行处理.3.最后catch一个父类Exception来捕获除自设异常外的其余异常.4.如果异常存在父子继承类关系,需先捕获子类异常.System.out.println("start");try{Stringstr=null; System.out.println(str.length());//只要try中出现异常,出现异常处之后的代码不会运行}catch(NullPointerExceptione){//()里写可能出现的异常 System.out.println("你大爷,出错了!");}System.out.println("over");2.finally块1.可以直接跟在try块之后或者最后一个catch块之后.2.无论try中代码是否出错,finally一定执行.3.通常将释放资源一类的操作放入finally中.面试题publicstaticvoidmain(String[]args){System.out.println(test(null)+","//3,3,3+test("")+","+test("0")); }publicstaticinttest(Stringstr){ try{ returnstr.charAt(0)-'0'; }catch(NullPointerExceptione){ return1; }catch(Exceptione){ return2; }finally{finally块代码一定会执行 return3; }将finally块中内容改为system.out.println("finallys!")运行后输出结果为finallys!Finallys!Finallys!1,2,0当test(null)调用test方法时,返回1的同时执行finally块内的代码,遂先会输出finally!当三次方法调用完,才会输出方法的返回值.3.throw关键字/throws关键字publicclassPerson{ privateintage; publicintgetAge(){ returnage; }} publicvoidsetAge(intage)throwsException{ if(age<0||age>100){ //使用throw抛出异常需使用throws声明抛出异常的方法后面来声明这个异常,RuntimeException及其子类除外. thrownewException("年龄不符和要求"); } this.age=age; }publicstaticvoidmain(String[]args){ Personp=newPerson(); try{ /* *调用含有throws方法时,必须要进行处理,有以下二方法: *1:使用try——catch自行捕获. *2:在当前方法上继续使用throws将该异常抛出. */ p.setAge(150); }catch(Exceptione){ } System.out.println("age："+p.getAge()); }子类重写父类含有throws抛出异常声明的方法时对throws的重写要求publicclassFather{ publicvoiddosome()throwsIOException,AWTException{ }}可以抛出异常的情况:classSonextendsFather{1.重写时可以不在抛出任何异常publicvoiddosome(){}2.重写时可以只抛出部分异常publicvoiddosome()throwsIOException{}3.可以抛出父类方法抛出异常的子类异常publicvoiddosome()throwsFileNotFoundException{}不可以抛出异常的情况:classSonextendsFather{

1.不可以抛出额外异常publicvoiddosome()throwsSQLException{}2.不可以抛出父类方法抛出异常的父类异常publicvoiddosome()throwsException{}Java异常可以分为可检测异常,非检测异常.RuntimeException类属于非检测异常,因为普通JVM操作引起的运行时异常随时可能发生,此类异常一般是由特定操作引发.但这些操作在java应用程序中会频繁出现.因此它们不受编译器检查与处理或声明规则的限制.Exception常用API1.voidprintStackTrace();//打印出异常情况try{…}catch(Exceptione){e.printStackTrace();//输出执行堆栈信息}2.StringgetMessage()//得到有关异常事件的信息try{…}catch(Exceptione){System.out.println(e.getMessage());}3.自定义Exception1)继承Exception自定义异常:publicclass[自定义异常类名]extendsException{…}2)编写构造方法:1.声明一个类并继承自Exception2.右键点击Source3.选择GenerateConstructorsfromSuperclass4.选中父类中所有构造方法后确认生成自定义抛出异常步骤：1.首先新建一个class[自定义异常类名]继承Exception,并编写构造方法.2.在对象类中声明并抛出异常.3.在main方法中获取抛出的异常并打印.1.首先新建一个class[自定义异常类名]继承Exception,并编写构造方法.publicclassgenderExceptionextendsException{privatestaticfinallongserialVersionUID=1L;//版本号编写构造:1.声明一个类并继承自Exception2.右键点击Source3.选择GenerateConstructorsfromSuperclass4.选中父类中所有构造方法后确认生成2.在对象类中声明并抛出异常.publicclassPerson{ privateStringgender; publicStringgetGender(){ returngender; } publicvoidsetGender(Stringgender)throwsgenderException{ if(gender=="男"||gender=="女"){ this.gender=gender; }else{ thrownewgenderException("人妖滚!"); } }}3.在main方法中获取抛出的异常并打印.publicclassTestPerson{ publicstaticvoidmain(String[]args){ Personp=newPerson(); try{ p.setGender("男1"); }catch(Exceptione){ e.printStackTrace();//获取异常并打印 } System.out.println(p.getGender()); }}进程是操作系统运行的一个任务,会分配一块独立的内存.进程中必须要有一个线程,所有线程共享进程分配的内存.并发原理:线程调度机制将时间划分为很多时间片段（时间片），尽可能均匀分配给正在运行的程序，获取CPU时间片的线程或进程得以被执行，其他则等待.(并发时,不要考虑先后问题)线程调度给cpu分配时间,来运行线程.线程状态new—>runnable—>running—>dead创建线程—有两种方法代码执行有先后顺序的称为"同步"执行,同步是在同一个线程中执行的代码.for(inti=0;i<1000;i++){ System.out.println("你谁啊?"); System.out.println("查水表");}方法一:继承Thread类并重写run方法classMyThreadextendsThread{ /** *run方法用来定义线程要执行的任务 */ @Override publicvoidrun(){ //线程执行的任务,例如下绿字 }}classMyThread2extendsThread{ @Override publicvoidrun(){ for(inti=0;i<1000;i++){ System.out.println("查水表"); } }}在main方法中创建线程类对象并使用start方法调用MyThreadt1=newMyThread1();MyThreadt2=newMyThread2();t1.start();t2.start();//t1,t2是并发的,不要考虑先后问题启动线程应当使用线程start方法,而不要直接调用run方法.start方法会快速的执行完毕,作用是将线程纳入线程调度,使其具有并发实行的能力.一旦线程获取CPU时间片开始运行时,会自动调用自己的run方法.需要注意,在概念上不能理解为调用start方法时run方法被执行.而是start方法执行完毕后该线程的run方法会很快被执行(一旦捕获时间片)优点:定义简单,适合匿名内部类快速创建线程.缺点:由于java是单继承的,这就导致继承了Thread就不能在继承其他类,在项目中拓展型差.由于将线程执行的任务定义在线程的run方法中,导致线程与任务有一个强耦合关系不利于线程重用.方法二:实现Runnable接口,并重写抽象方法run来定义任务.classMyRunnable1implementsRunnable{ @Override publicvoidrun(){ for(inti=0;i<1000;i++){//定义的任务 System.out.println("你谁啊?"); } }}classMyRunnable2implementsRunnable{ @Override publicvoidrun(){ for(inti=0;i<1000;i++){ System.out.println("我是修水管的"); } }}main方法中先实例化任务,后实例化线程,再使用start启用//实例化任务MyRunnable1r1=newMyRunnable1();MyRunnable2r2=newMyRunnable2();//实例化线程Threadt1=newThread(r1);Threadt2=newThread(r2);t1.start();t2.start();使用匿名内部类创建线程publicstaticvoidmain(String[]args){ //方法一 Threadt1=newThread(){ publicvoidrun(){ for(inti=0;i<1000;i++){ System.out.println("你是谁啊?"); } } }; //方法二 Runnablerunn=newRunnable(){ publicvoidrun(){ for(inti=0;i<1000;i++){ System.out.println("我是查水表的"); } } }; Threadt2=newThread(runn); //线程启动t1.start(); t2.start(); }匿名内部类:intera=newinter(){}1.创建了inter的子类,没有名字2.为该子类创建了一个对象,名为a3.{}中填写类体线程操作API获取运行当前方法的线程staticThreadcurrentThread()查看运行main方法的线程Threadt=Thread.currentThread();System.out.println(t);//Thread[main,5,main]查看运行自定义方法的线程publicstaticvoidmain(String[]args){dosome();//运行dosome方法的线程是Thread[main,5,main]}publicstaticvoiddosome(){ Threadt=Thread.currentThread(); System.out.println("运行dosome方法的线程是"+t);}查看运行的自定义线程在自设线程中查看运行自定义方法的线程publicstaticvoidmain(String[]args){Threadmy=newThread(){ publicvoidrun(){ Threadt=Thread.currentThread(); System.out.println(t); dosome();//调用查看运行自定义方法的线程的方法 } }; my.start();}输出结果:Thread[Thread-0,5,main]运行dosome方法的线程是Thread[Thread-0,5,main]获取线程信息的相关方法获取运行main方法的线程Threadt=Thread.currentThread(); 获取IDlongid=t.getId();System.out.println(id); 获取名字Stringname=t.getName();System.out.println(name); 获取线程优先级intpriority=t.getPriority();System.out.println("优先级"+priority); 线程是否存活booleanisAlive=t.isAlive();System.out.println("isAlive"+isAlive); 是否是守护线程booleanisDaemon=t.isDaemon();System.out.println("isDaemon"+isDaemon); 是否被中断booleanisInterupted=t.isInterrupted();System.out.println("isInterupted"+isInterupted);线程优先级voidsetPriority(intPriority)划分为10级,值为1-10,其中1最低,10最高Thread.MIN_PRIORITY最低Thread.MAX_PRIORITY最高Thread.NORM_PRIORITY基础Threadt=newThread(){ publicvoidrun(){ 需要执行的任务 }};Thread.MAX_PRIORITYThread.MIN_PRIORITYt.setPriority(Thread.NORM_PRIORITY);//设置优先级t.start();//启用线程sleep方法用于使当前线程进入阻塞状态 延迟该方法会使当前线程进入阻塞状态指定毫秒，当指定毫秒阻塞后，当前线程会重新进入Runnable状态，等待分配时间片.publicstaticvoidmain(String[]args){ System.out.println("程序开始了"); try{ Thread.sleep(5000); }catch(InterruptedExceptione){ } System.out.println("程序结束了");}该方法声明抛出一个InterruptException。所以在使用该方法时需要捕获这个异常电子表功能publicstaticvoidmain(String[]args){ /* *循环显示 *每秒钟在控制台输出当前系统时间 *格式:15:17:08 */SimpleDateFormatsdf=newSimpleDateFormat("HH:mm:ss"); while(true){ Datedate=newDate(); Stringstr=sdf.format(date);System.out.println(str); try{ Thread.sleep(1000); }catch(InterruptedExceptione){ } }}守护线程后台线程voidsetDaemon(boolean)boolean为true为后台线程当进程中前台进程都结束只剩下守护线程时,所有守护线程都强制终止.publicstaticvoidmain(String[]args){ Threadrose=newThread(){ publicvoidrun(){ for(inti=0;i<5;i++){ System.out.println("rose:letmego!"); try{ Thread.sleep(1000); }catch(InterruptedExceptione){ } } System.out.println("啊啊啊啊啊AAAAAAaaaaaa"); System.out.println("KO"); } }; Threadjack=newThread(){ publicvoidrun(){ while(true){ System.out.println("jack:youjump!ijump!"); try{ Thread.sleep(1000); }catch(InterruptedExceptione){ } } } }; jack.setDaemon(true); rose.start(); jack.start(); while(true);//空内容的死循环,保持main线程不结束System.out.println("我先走");}main线程最先结束,当rose线程结束时,守护线程jack也强制结束若main线程不结束,当rose线程结束时,守护线程jack依旧运行输出结果:我先走rose:letmego!jack:youjump!ijump!rose:letmego!jack:youjump!ijump!rose:letmego!jack:youjump!ijump!rose:letmego!jack:youjump!ijump!rose:letmego!jack:youjump!ijump!啊啊啊啊啊AAAAAAaaaaaaKOjack:youjump!ijump!若在main中有while(true)使main线程不结束,那么会继续输出jack:youjump!ijump!...即jack不结束join方法voidjoin() 该方法声明抛出InterruptException. 该方法会阻塞运行该方法的线程,使其在join方法所属线程对象上等待,直到其完成工作才会解除阻塞继续运行. join是用来协调多个线程间同步工作的. 在方法内部类中调用join方法时,调用方需要final修饰publicstaticbooleanisFinish;publicstaticvoidmain(String[]args){ finalThreaddownload=newThread(){ publicvoidrun(){ System.out.println("down:开始下载图片."); for(inti=1;i<101;i++){ try{ Thread.sleep(80); }catch(InterruptedExceptione){ } System.out.println("down:"+i+"%"); } System.out.println("down:图片下载完毕"); isFinish=true; } }; Threadshow=newThread(){ publicvoidrun(){ System.out.println("show:开始显示图片"); //应当等待下载线程将图片下载完毕 try{ download.join(); }catch(InterruptedExceptione){ } if(!isFinish){ thrownewRuntimeException("还没下完"); } System.out.println("show:显示图片完毕!"); } }; download.start(); show.start();}线程同步synchronized关键字一.修饰成员方法只有上锁的是同一个对象才具有同步型使用synchronized修饰方法,让整个方法同步同步方法线程依次进入方法,效率低publicclassSyncDemo1{ publicstaticvoidmain(String[]args){ finalTabletable=newTable(); Threadt1=newThread(){ publicvoidrun(){ while(true){ intb=table.getBean(); Thread.yield(); System.out.println(getName()+":"+b); } } }; Threadt2=newThread(){ publicvoidrun(){ while(true){ intb=table.getBean(); Thread.yield(); System.out.println(getName()+":"+b); } } }; t1.start(); t2.start(); }}classTable{ privateintbeans=2000; /** *当一个方法被synchronized修饰后,当前方法称为"同步方法", *多个线程不能同时进入方法内部执行,只能"排队执行".*要想解决多线程并发安全问题,就需要将执行代码从"异步"(各干各的)变为"同步"(排队干)执行.*当在