betway必威体育app官网Java基础知识总计

Java基础知识总结

betway必威体育app官网 1

JVM

 

W3C JAVA教程

JAVA考古学

 

StringBuffer 和StringBuilder中的两个函数:

  1. //int indexOf(String str) :重返当前StringBuffer对象中,第一个满意str子串的地方。  
  2. //int indexOf(String str, int fromIndex) :从fromIndex最先查找,重回第一个满意str子串的地点。  
  3.           
  4. StringBuffer sb = new StringBuffer(“This is a StringBuffer!”);  
  5. System.out.println(“sb.indexOf(\”is\”) = ” + sb.indexOf(“is”));  //2  
  6. System.out.println(“sb.indexOf(\”is\”, 4) = ” + sb.indexOf(“is”, 4));   //5  
  7. System.out.println(“sb.indexOf(\”is\”, 4) = ” + sb.indexOf(“is”, 7));   // -1  
  8.           
  9. //StringBuffer insert(int offset, String str)  
  10. //在现阶段StringBuffer对象中插入一个要素,在索引号offset处插入相应的值。    
  11.         
  12. StringBuffer sf = new StringBuffer(“..{..}) public class ESBYSYSInquiryMachineInfoSrvRequest {“);  
  13. int classIdx = sf.indexOf(“public class “);  
  14. if(classIdx > 0){  
  15.       sf.insert(sf.indexOf(“{“, classIdx), ” implements java.io.Serializable”);  
  16. }  
  17. System.out.println(sf.toString());  
  18. //..{..}) public class ESBYSYSInquiryMachineInfoSrvRequest  implements java.io.Serializable{  

 

 

 2.保留2位小数:

 

  1. import java.text.DecimalFormat;  
  2. DecimalFormat df=new DecimalFormat(“0.00”);  
  3. Double x = 83.3333333333;  
  4. x=Double.parseDouble(df.format(x));   

 3.group by 和 order by

 

  1. ORDER BY 用于对数码按指定的列和艺术排序。  
  2.   
  3. select * from syscolumns order by id asc, colorder desc;  
  4. 指令查询出的结果 按 id 正序排列, colOrder 逆序排列。  
  5.   
  6. GROUP BY 用于汇总总括。 HAVING 用途和 WHERE类似,但用于对 GROUP BY 的结果举办过滤。  
  7. select id, count(id) from syscolumns group by id;  
  8. 这条语句以 id 举行集中,总括出每个不同的 id 出现的个数。  
  9.   
  10. select id, count(id) from syscolumns group by id having count(1) > 10;  
  11. 这条语句以 id 举办汇总,总括出每个不同的 id 出现的个数,但 having 后的尺码指定了只显示 count(id) 大于 10 的数据。。  
  12.   
  13. 先Group by ,后 Order by  

 4.日期

赢得当前光阴:

  1. 1.  
  2. SimpleDateFormat tempDate = new SimpleDateFormat(“yyyy-MM-dd” + ” ” + “hh:mm:ss”);  
  3. String datetime = tempDate.format(new java.util.Date());  
  4.   
  5. 2.  
  6. Calendar now=Calendar.getInstance();  
  7. String time=now.get(Calendar.YEAR)+”-“+(now.get(Calendar.MONTH)+1)+”-“+now.get(Calendar.DAY_OF_MONTH)+” “+now.get(Calendar.HOUR_OF_DAY)+”:”+now.get(Calendar.MINUTE)+”:”+now.get(Calendar.SECOND);  
  8.    
  9.   
  10. 3.Date curDate= new Date(System.currentTimeMillis());  

  11. SimpleDateFormat format = new  SimpleDateFormat( “yyyy-MM-dd HH:mm:ss” ); //24小时制   

  12. SimpleDateFormat format = new SimpleDateFormat(“yyyy-MM-dd hh:mm:ss”);//12小时制   

  a.获取年、月、日:

  1. String year=String.valueOf(c.get(Calendar.YEAR));  
  2. String month=String.valueOf(c.get(Calendar.MONTH)+1);             
  3. String day=String.valueOf(c.get(Calendar.DAY_OF_MONTH));  

 

b.Calendar和Date的转化 

(1) Calendar转化为Date

  1. Calendar cal=Calendar.getInstance();  
  2. Date date=cal.getTime();   

 
(2) Date转化为Calendar

  1. Date date=new Date();  
  2. Calendar cal=Calendar.getInstance();  
  3. cal.setTime(date);   

 

 

c.总计一年中的第几星期 

(1)总计某一天是一年中的第几礼拜

  1. Calendar cal=Calendar.getInstance();  
  2. cal.set(Calendar.YEAR, 2006);  
  3. cal.set(Calendar.MONTH,1);  
  4. cal.set(Calendar.DAY_OF_MONTH, 3);  
  5. int weekno=cal.get(Calendar.WEEK_OF_YEAR);  

 

(2)统计一年中的第几星期是几号

  1. SimpleDateFormat df=new SimpleDateFormat(“yyyy-MM-dd”);  
  2. Calendar cal=Calendar.getInstance();  
  3. cal.set(Calendar.YEAR, 2006);  
  4. cal.set(Calendar.WEEK_OF_YEAR, 1);  
  5. cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);  
  6. System.out.println(df.format(cal.getTime()));  
  7. 输出:  
  8. 2006-01-02   

 d:

 

  1天内(注意为add ):

  1. Calendar c=Calendar.getInstance();            
  2. c.add(Calendar.DAY_OF_MONTH, -1);  //得到前一天的年月  
  3. startDateStr=sf.format(c.getTime());  
  4.   
  5. endDateStr=sf.format(java.util.Calendar.getInstance().get提姆e()); 推荐应用这种措施得到当前天子,不推荐应用new Date()  

  3天内:

  1. Calendar c=Calendar.getInstance();            
  2. c.add(Calendar.DAY_OF_MONTH, -3);  //拿到前3天的日子  
  3. startDateStr=sf.format(c.getTime());  

  近1月:

  1. Calendar c=Calendar.getInstance();  
  2. c.add(Calendar.MONTH, -1);  
  3. startDateStr=sf.format(c.getTime());          

 到当下时刻的前些年的时光:

  1. Calendar   c   =   Calendar.getInstance();     
  2.  c.add(Calendar.YEAR, -5);//得到前5年    
  3.  SimpleDateFormat formatter = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);    
  4.  String mDateTime=formatter.format(c.getTime());    
  5.  String strStart=mDateTime.substring(0, 16);//2002-10-24 09:30   

 

 

本月(注意为set ):

  1. Calendar c=Calendar.getInstance();  
  2. c.set(Calendar.DATE,1); //把日期设为当月第一天                  
  3. startDateStr=sf.format(c.getTime());          

 上月:

 

  1. Calendar c2=Calendar.getInstance();  
  2.  c2.add(Calendar.MONTH,-1);  
  3.  c2.set(Calendar.DATE,1);             
  4.  startDateStr=sf.format(c2.getTime());  

 

5.文本域input的不可编辑属性 disabled 和  readonly  区别

 

都足以实现都足以实现input的不行编辑,但有区别…

disable 属性 — 表示曾经失效的输入域

readonly 属性 — 表示只读(只能见到,不可以改改)的输入域(框)

 

  1. <input type=”checkbox” value=”2″  name=”fav” disabled=”disabled” />  
  2.   
  3. <input type=”text”  name=”notinput” readonly=”readonly” />   

 

  1.  /**是不是闰年   
  2.   */    
  3. public boolean isLeapYear(int year) {  
  4.     return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);     }  

 具体日子操作:

http://www.360doc.com/content/09/0820/17/236102_5085810.shtml

可将当选的代码拖动到QQ聊天窗口中复制

6.File协议 

  
代表当地文件传输协议,File协议重要用以访问当地电脑中的文件 ,就如同在Windows资源管理器中开拓文件一律。
  
应用:要利用File协议,基本的格式如下:file:///文件路径,比如要打开F:盘flash文件夹中的1.swf文件,那么可以在资源管理器或IE地址栏中键入:file:///f:/flash/1.swf并回车。

3个斜杠代表当地

 

 

8.substring(int beginIndex, int endIndex)

 

该子字符串从指定的 beginIndex 处起始,直到索引 endIndex – 1
处的字符。由此,该子字符串的长度为 endIndex-beginIndex。
    示例:
         “hamburger”.substring(4, 8) returns “urge”
         “smiles”.substring(1, 5) returns “mile ”  
    参数:
        beginIndex – 起头索引(包括)。 
        endIndex – 停止索引(不包括) 。

 

9.哪些时候用Thread.getContextClassLoader()

     需要动态加载很多类和资源的时候 .

       平日当您需要动态加载资源的时候 , 你至少有几个 ClassLoader 可以选拔 :

²        系统类加载器或叫作应用类加载器 (system classloader or
application classloader)

²        当前类加载器

²        当前线程类加载器

 

10.instanceof 运算符 
指出对象是否是特定类的一个实例。

  1. String s = “I AM an Object!”;  
  2. boolean isObject = s instanceof Object;  
  3.   
  4. public double calculate(Bill bill) {  
  5.   if (bill instanceof PhoneBill) {  
  6.   //统计电话账单  
  7.   }  
  8. }  

 11、java环境布置(都放上边):

CLASSPATH   .;%JAVA_HOME%\lib

JAVA_HOME   C:\Program Files\Java\jdk1.6.0_22

Path  .;%JAVA_HOME%\bin

 

 

13.JDK1.5的新特色

“JDK1.5”(开发代号猛虎)的一个重大焦点就是经过新增部分特点来简化开发 ,那个特点包括泛型,for-each循环,自动装包/拆包,枚举,可变参数, 静态导入 。使用那个特征有助于大家编辑更加清晰,精悍,安全的代码。

电动装包/拆包

机关装包/拆包大大有利了基本类型数据和它们包装类地应用。
自动装包:基本项目自动转为包装类.(int >> Integer)
机关拆包:包装类活动转为基本类型.(Integer >> int)
在JDK1.5之前,大家总是对碰面无法存放基本项目而言犹在耳,现在机关转换机制解决了我们的题目。

在其实支付过程中,我们平时会遭逢需要采用对象,而不是置于数据类型的事态。为了解决这多少个题材,Java语言为每一个置于数据类型提供了相应的包装类。

不无的包装类(Integer、Long、Byte、Double、Float、Short)都是抽象类Number的子类。

 

此处Integer先自动转换为int进行加法运算,然后int再度转移为Integer.

  1. int a = 3;  
  2. Collection c = new ArrayList();  
  3. c.add(a);//自动转换成Integer.  
  4.   
  5. Integer b = new Integer(2);  
  6. c.add(b + 2);  

 枚举:

  1. public enum Color  
  2. {  
  3.    Red,  
  4.    White,  
  5.    Blue  
  6. }  

 然后可以这样来行使Color myColor = Color.Red.
枚举类型还提供了六个有效的静态方法values()和valueOf(). 我们能够很便宜地利用它们,例如

  1. for (Color c : Color.values())  
  2.    System.out.println(c);  

带构造函数的枚举:

  1. public enum Color {  
  2.   
  3.     RED(“红色”),BLUE(“蓝色”),GREEN(“绿色”);  
  4.       
  5.     private final String name;  
  6.   
  7.     public  String getName() {  
  8.         return name;  
  9.     }  
  10.     private Color(String name){  
  11.         this.name=name;  
  12.     }  
  13. }  

 

  1. System.out.println(“Color.RED.name():”+Color.RED.name());         //RED  
  2. System.out.println(“Color.RED.toString():”+Color.RED.toString()); //RED  
  3. System.out.println(Color.RED.getName());    //红色  

 Color.RED.name()

 Color.RED.toString(); 拿到的都是RED

1、Color枚举类是独特的class,其枚举值(RED,BLUE…)是Color的类对象(类实例):Color
c=Color.RED ;
并且那个枚举值都是public static
final的,也就是咱们平常所定义的常量,因而枚举类中的枚举值最好一切大写 。
2、即然枚举类是class,当然在枚举类型中有构造器,方法和数据域。可是,枚举类的构造器有很大的例外:
(1) 构造函数只是在结构枚举值的时候被调用。
(2) 枚举构造函数只好私有private ,相对不允许有public构造器。这样可以确保表面代码不能新社团枚举类的实例。因为大家了解枚举值是public
static final的常量而已 但枚举类的情势和数据域可以允许外部访问。

 

  1. /** 
  2.  *  
  3.  * 服务器类型 
  4.  *  
  5.  */  
  6. public enum ServerType {  
  7.       
  8.     JBoss(“server/default/deploy”,”client,common”), WebLogic(“”,””), GlassFish(“”,””);  
  9.       
  10.     private String deployPath;  
  11.       
  12.     private String libClassPath;  
  13.       
  14.     private ServerType(String deployPath, String libClassPath){  
  15.         this.deployPath = deployPath;  
  16.         this.libClassPath = libClassPath;  
  17.     }  
  18.       
  19.     public String getDeployPath(){  
  20.         return this.deployPath;  
  21.     }  
  22.       
  23.     public String getLibClassPath(){  
  24.         return this.libClassPath;  
  25.     }  
  26. }  

 ServerType serverType = ServerType.JBoss;

String deployPath = serverType.getDeployPath();
String libClassPath = serverType.getLibClassPath();

 

 

可变参数:

当不可能确定一个方法的输入参数的个数时,以往版本的Java中,平常的做法是将两个参数放在一个数组或者目的集合中作为参数来传递,1.5版本在此以前的写法是:

  1. int sum(Integer[] numbers)    
  2. {    
  3.   int nSum = 0;    
  4.   for(int i: numbers)    
  5.   nSum += i;    
  6.   return nSum;    
  7. }  

 在别处调用该方法  
sum(new Integer[] {12,13,20});

 

而在1.5版本中得以写为:

  1. public static int sum(Integer… number){  
  2.     int nSum=0;  
  3.     for(int i : number){  
  4.         nSum+=i;  
  5.     }         
  6.     return nSum;          
  7. }  

 在别处调用该方法

  1. System.out.println(“sum():”+sum(12,13,14));  
  2. System.out.println(“sum():”+sum(12,13));  

静态导入

要拔取静态成员(方法和变量)我们务必提交提供那么些法子的类。使用静态导入可以使被导入类的装有静态变量和静态方法在当下类直接可见,使用这些静态成员无需再提交他们的类名。
唯独,过度施用这些特性也会肯定水准上降落代码地可读性。

  1. import static java.lang.Math.*;  
  2. …….  
  3. r = sin(PI * 2); //无需再写r = Math.sin(Math.PI);  

 

14.o1.CompareTo(o2);

整形间相比会再次回到1、-1、0

如:

  1.     public static void main(String[] args) {  
  2.         //Integer num1;  
  3.         //num1 = new Integer(“24”);  
  4.         //Integer num2;  
  5.         //num2 = new Integer(“34”);  
  6.         Integer num2=12; //不可使用 int num2=12;因compareTo(T t)中的T是类,所以必须用包装类  
  7.         Integer num1=11;  
  8.         System.out.println(num2.compareTo(num1));  
  9. //1         System.out.println(“——————“);  
  10.         System.out.println(num1.compareTo(num2));  
  11. //-1    }  

 字符串间相比较:

 

       “abcd” .compareTo( “adef” )== -2

       “abc” .compareTo( “abcdef” )== -3

       “abc” .compareTo( “abc” ) == 0

 

简单 字符串的排序 。(例如使用 compareTo 进行姓名的排序)

 

  1. //需要举办排序的字符串  
  2. String[] array = new String[] { “lilei”, “libai”, “james”, “poly”,  
  3.                 “wobfei” };  
  4. //使用简便的循环排序  
  5.         for (int i = 0; i < array.length ; i++) {  
  6.             for (int j = i + 1; j < array.length-1; j++) {  
  7.                 if (array[i].compareTo(array[j]) > 0) {  
  8.                     String temp = array[i];  
  9.                     array[i] = array[j];  
  10.                     array[j] = temp;  
  11.                 }  
  12.             }  
  13.         }  

   

应用方面针对 String 的排序以后,字符串的情节将会是:

james  libai  lilei  poly  wobfei

该例子来源(稍作了修改):http://wobfei.iteye.com/blog/743123

 

15.编码层出不穷

add、saveAdd

edit、saveEdit

 

16、Math.round();

 

Math.round(m) = (int)Math.floor(a + 0.5f)

Math.ceil(x):比x大的蝇头值。 
Math.round(x):四舍五入。 
Math.floor(x):比x小的最大值。

 

jdk说得很了然了, 
-11.5+0.5=-11   Math.floor(-11)=-11 
-11.3+0.5=-10.8   Math.floor(-10.8)=   -11 
-11.8+0.5=-11.3   Math.floor(-11.3)=   -12

 

 

17、重写

有关重写,服从以下的平整:

(1)重写方法必须和被重写方法具有同等的参数列表, 再次回到类型必须和被重写方法的归来类型相同或者是重返类型的子类型 。

(2)重写方法的访问控制修饰符不可以比被重写方法更严谨(比如一个在父类中扬言为public的办法重写成一个protected的点子)。

 

 

18.

  1. class Test {  
  2.     void test(int i) {  
  3.         System.out.println(“I am an int.” + i);  
  4.     }  
  5.   
  6.     void test(String s) {  
  7.         System.out.println(“I am a string.”);  
  8.     }  
  9.   
  10.     public static void main(String args[]) {  
  11.         Test t = new Test();  
  12.         char ch = ‘y’;  
  13.         t.test(ch);  
  14.     }  
  15.     //结果为:I am an int.121  
  16. }  

 

19.JDBC的重点职责是何等?(六个)

1、建立与数据库的连日。
2、向数据库发起查询请求。
3、处理数据库重回结果。

 

20.TreeSet的构造函数

TreeSet();

TreeSet(Collection c);//构造一个含有指定 collection 元素的新
TreeSet,它遵照其元素的本来顺序 举行排序。

TreeSet(Comparator comparator);//构造一个新的空
TreeSet,它依据指定相比较器举行排序。

  1. public class NameComparator implements Comparator<Name>{  
  2.       
  3.     public int compare(Name n1,Name n2){  
  4.         if(n1.getName().compareTo(n2.getName())>0) return -1;  
  5.         if(n1.getName().compareTo(n2.getName())<0) return 1;  
  6.           
  7.         return 0;  
  8.     }  
  9.       
  10.     public static void main(String[] args) {  
  11.         Set<Name> set = new TreeSet<Name>(new NameComparator());  
  12.           
  13.         Name n1 = new Name(“ray”);  
  14.         Name n2 = new Name(“tom”);  
  15.         Name n3 = new Name(“jame”);  
  16.         set.add(n1);  
  17.         set.add(n2);  
  18.         set.add(n3);  
  19.           
  20.         Iterator it = set.iterator();  
  21.         while(it.hasNext()){  
  22.             Name s = (Name)it.next();  
  23.             System.out.print(s.getName()+”,”);  
  24.         }  
  25.         System.out.println(“一共有对象:”+set.size()+”个”);  
  26.     }  
  27. }//打印结果是:tom,ray,jame,一共有对象:3个  

 客户端排序时因为java.util.Comparator<Type>接口提供了实际的排序模式,<Type>指定了被相比对象的体系,Comparator有个compare(Type
x,Type y)的不二法门,用于相比较六个对象的轻重缓急。

 

21.Object中的hashcode()和equals()

   在Java中任何一个目标都持有equals(Object
obj)和hashcode()这六个措施,因为她俩是在Object类中定义的。 
equals(Object
obj)方法用来判断两个对象是不是“相同”,假若“相同”则赶回true,否则再次回到false。 
hashcode()方法再次来到一个int数,在Object类中的默认实现是“将该目的的内部地址转换成一个整数重回”。 
   
接下去有五个个有关这五个法子的紧要标准(我只是抽取了最首要的五个,其实不止四个): 
正规1: 若重写equals(Object
obj)方法,有必不可少重写hashcode()方法,确保通过equals(Object
obj)方法判断结果为true的六个目的拥有异常的hashcode()再次来到值。说得简单点就是:“一经五个目的相同,那么她们的hashcode应该
相等”
。然而请留心:那个只是正规,假使你非要写一个类让equals(Object
obj)重回true而hashcode()再次来到多少个不对等的值,编译和运作都是不会报错的。然而这样违反了Java规范,程序也就埋下了BUG。 
规范2: 假设equals(Object
obj)重回false,即六个目的“不雷同”,并不要求对这六个对象调用hashcode()方法赢得六个不一致的数。说的大概点就是:“只要几个对象不平等,他们的hashcode可能同样”。 
     遵照这多少个标准,可以拿到如下推论: 
1、假如六个目的equals,Java运行时环境会认为他俩的hashcode一定相等 。 
2、如果两个对象不equals,他们的hashcode有可能 相等。 
3、假如四个目标hashcode相等,他们不肯定 equals。 
4、假诺四个对象hashcode不对等,他们自然不 equals。

 

http://www.iteye.com/topic/800929

 

22.序列化

序列化的目的要贯彻Serializable接口,
Serializable接口没有索要实现的情势,
implements Serializable只是为了标明该目的是可被体系化的,
下一场 使用一个输出流(如:FileOutputStream)来协会一个ObjectOutputStream(对象流)对象 ,接着,使用ObjectOutputStream对象的writeObject(Object
obj)方法就可以将参数为obj的对象写出(即保存其场馆),要东山再起的话则用输入流。

贯彻体系化(保存到一个文书)的步骤 
a)Make a FileOutputStream             
      FileOutputStream fs = new FileOutputStream(“foo.ser”);     
b)Make a ObjectOutputStream           
      ObjectOutputStream os =  new ObjectOutputStream(fs);    
c)write the object 
     os.writeObject(myObject1);   
     o s.writeObject(myObject2);   
     os.writeObject(myObject3);   
d) close the ObjectOutputStream 
     os.close();  

 

 

23、计划任务:

java.util.Timer

timer.schedule(…);

http://www.blogjava.net/georgehill/archive/2005/06/09/5793.aspx 

 

http://www.klstudio.com/post/187.html

 

 

24.Split

在java.lang包中有String.split()方法,重返是一个数组
自身在运用中用到部分,给我们统计一下,仅供我们参考:
1、如果用“.”作为分隔的话,必须是之类写法:String.split(“\\.”),这样才能科学的相间开,不能够用String.split(“.”);
2、倘诺用“|”作为分隔的话,必须是之类写法:String.split(“\\|”),这样才能正确的相间开,不可能用String.split(“|”);
“.”和“|”都是转义字符,必须得加”\\”;
3、假如在一个字符串中有五个分隔符,可以用“|”作为连字符,比如:“acount=? and uu =? or n=?”,把两个都分隔出来,可以用String.split(“and|or”);

java转义字符

     \”:双引号 
     \’:单引号 
     \\:反斜线

 

25.成效范围:

this.context.setAttribute(MyConstants.CONTINENTS_KEY, continentlist);
public static final String CONTINENTS_KEY=”CONTINENTS”;
jsp页面中可以间接运用 CONTINENTS(${CONTINENTS })
,而无需context.getAttribute(“”);

 

  1. <body>  
  2.   <% request.setAttribute(“name”,”xiaoming”) ;%>      
  3.   <input type=”text” value=”${name}”/>  
  4. </body>  

 

26.数组转为list

  1. List stooges = Arrays.asList(“Larry”, “Moe”, “Curly”);    

  此时stooges中有有两个元素。注意:此时的list不可以拓展add操作,否则会报
“java.lang.UnsupportedOperationException”,Arrays.asList()重返的是List,而且是一个定长的List,所以不可能更换为ArrayList,只可以转换为AbstractList
 原因在于asList()方法再次回到的是某个数组的列表形式,重临的列表只是数组的另一个视图,而数组本身并没有收敛,对列表的别样操作最后都展示在数组上.
所以不帮忙remove,add方法的

  1. String[] arr = {“1”, “2”};    
  2. List list = Arrays.asList(arr);    

 

任何情势:

  1. String[] strArray = new String[] { “aa”, “bb” };  
  2.         List<String> list = new ArrayList<String>(Arrays.asList(strArray));  
  3.         list.add(“cc”);  
  4.         System.out.println(list);  

 结果:[aa, bb, cc]

 

27、使用ResourceBundle读取properties文件

奇迹有些简单的配备文件可以没必要接纳xml,其实ResourceBundle类就早已做的很好的。它竟然可以查找到classpath里的jar文件中有些properties文件。

比如说在jar文件中的根目录放置一个文本:test.properties,然后一旦这多少个jar文件在classpath里。就可以利用这样的语句来得到部分性能:

  1. ResourceBundle rb = ResourceBundle.getBundle(“test”);  
  2.   String s = rb.getString(“FirstKey”);  
  3.   System.out.println(s);  

  28、HttpClient学习

  1. public class TestHttpClient {  
  2.   
  3.     public static void main(String[] args) {  
  4.         String url = “http://images.gta-travel.com/HH/Images/HX/HKGA/HKGA-REG-1.jpg|http://images.gta-travel.com/HH/Images/HX/HKGA/HKGA-REG-2.jpg“;  
  5.         String[] urlArr = url.split(“\\|”);  
  6.         String fileName = “D:\\httpClient”;       
  7.           
  8.         HttpClient client = new HttpClient();        
  9.         GetMethod method = new GetMethod(urlArr[1]);          
  10.             // 使用 GET 方法 ,倘使服务器需要经过 HTTPS 连接,这只需要将下边 URL 中的 http 换成 https   
  11.           
  12.         FileOutputStream output = null;  
  13.         try {  
  14.             client.executeMethod(method);  
  15.             File showFile = new File(fileName + “.jpg”);              
  16.               
  17.             output = new FileOutputStream(showFile);  
  18.             output.write(method.getResponseBody()); //method.getResponseBody()为byte[]类型  
  19.             output.flush();  
  20.         } catch (HttpException e) {           
  21.         } catch (IOException e) {             
  22.         } finally {           
  23.             if (output != null) {  
  24.                 try {  
  25.                     output.close();  
  26.                     output = null;  
  27.                 } catch (IOException e) {                     
  28.                 }  
  29.             }  
  30.         }  
  31.     }  
  32. }  

 

http://www.blogjava.net/Alpha/archive/2007/01/22/95216.html

 

29、栈、堆

1.寄存器:最快的存储区, 由编译器依照需求举办分配,我们在先后中不可以控制.
2.
栈:存放基本项目的变量数据和对象的引用,但目的自我不存放在栈中,而是存放在堆(new
出来的目的)或者常量池中(字符串常量对象存放在常量池中。)

  1. 堆:存放所有new出来的对象。
    4. 静态域 :存放静态成员(static定义的)
    5. 常量池 :存放字符串常量主干项目常量(public static
    final)。
  2. 非RAM存储:硬盘等永久存储空间
    此地我们任重而道远关注栈,堆和常量池,对于 栈和常量池中的对象足以共享,对于堆中的对象不可以共享。栈中的多寡大小和生命周期是能够规定的,当没有引用指向数据时,这么些数据就会不复存在。堆中的对象的由垃圾回收器负责回收,由此大小和生命周期不需要确定 ,具有很大的灵活性。
    对于字符串:其目的的引用都是储存在栈中的,假设是 编译期已经创设好(直接用双引号定义的)的就存储在常量池中,要是是运行期(new出来的)才能确定的就存储在堆中 。对于equals相等的字符串,在常量池中永远只有一份,在堆中有多份。

new String(“China”);
对此因此new爆发一个字符串(假使为”china”)时,会先去常量池中寻找是否早已有了”china”对象,假诺没有则在常量池中开创一个此字符串对象,然后堆中再成立一个常量池中此”china”对象的正片对象。这也就是有道面试题:String
s = new
String(“xyz”);暴发多少个对象?一个或多少个,假诺常量池中原本没有”xyz”,就是六个。

 

对于成员变量和部分变量:成员变量就是办法外部,类的里边定义的变量;局部变量就是措施或语句块内部定义的变量。局部变量必须初阶化。
款式参数是有的变量,局部变量的多寡存在于栈内存中 。栈内存中的片段变量随着方法的没有而没有。
成员变量存储在堆中的对象里面 ,由垃圾回收器负责回收

http://www.iteye.com/topic/634530

 

30.try-catch

  1. public class Test {    
  2.     
  3.     public static void main(String[] args) {     
  4.         System.out.println(“return value of getValue(): ” + getValue());     
  5.     }     
  6.     
  7.        public static int getValue() {     
  8.         int i = 1;     
  9.         try {     
  10.                  return i;     
  11.         } finally {     
  12.             System.out.println(“i :  finally”);    
  13.             ++i;     
  14.         }     
  15.     }     
  16.     
  17. }  

 

  1. public static boolean get() {    
  2.      try {    
  3.             return  false;    
  4.      } finally {    
  5.             return  true;    
  6.      }    
  7.  }   

 在try中的return真正再次来到此前 ,会将false保存到一个临时变量(假如为var)中 ,然后实施finally,在实施finally子句的其它语句往日,会将var中的值取出,假如finally中一贯不抛出至极或return、break、continue等说话,则在finally执行完后重返var (相当于再次回到去做到try中return的举行),如若finally中有return,var值会被覆盖 ,重临结果是finllay子句中
return的值,如果是可怜或break、continue等则执行相应的操作而不是回去。更详实表达参照JVM规范或《浓密理解JAVA虚拟机(第二版)》。

实在一定于值传递

结果:1    true

 

31、重回一个n位随机数

random.nextInt(n)

返回0~n 间的平头,包括0,不包括n

  1. public static String getRandStr(int n){    
  2.         Random random = new Random();    
  3.         String sRand = “”;    
  4.         for (int i = 0; i < n; i++) {    
  5.             String rand = String.valueOf(random.nextInt(10));    
  6.             sRand += rand;    
  7.         }    
  8.         return sRand;     
  9.     }   

 getRandStr(4)可回到一个4为数

32、java中的main方法

String
args[]保留的是 JAVA运行时传递给所运行类的参数,你那么些类需要参数就传,不需要就不传.

  1. public class TestMain{  
  2.     public static void main(String args[]){  
  3.         for(int i=0;i<args.length;i++){  
  4.             System.out.println(args[i]);  
  5.         }  
  6.     }  
  7. }  

 
接着用java TestMain first second运行
结果:
first
second

 

args实际上是个变量。它用来储存你用命令后执行.class文件时后边跟的参数。args是可以变的,你可以改为你喜爱的肆意标识符。
一般方法其实可以不给,只是你在规划方法的时候要给一个不传参数的法门。

 

注意:

1、其回到类型应该为void

2、必须为集体艺术

写道

  1. 哪一个对单机程序中的main()方法的宣示是张冠李戴的?(多选)DE

a. public static void main()
b. public static void main(String[] string)
c. public static void main(string args)
d. static public int main(String[] args)
e.static void main(String[] args)

33、Map遍历

  1. for(Map.Entry<String, String>  entry : map.entrySet()){       
  2.     System.out.println(entry.getKey()+”—>”+entry.getValue());       
  3. }    

 

34、for循环

for语句的格式为:

  for (初始化语句; 条件语句; 控制语句)
  {
    语句1 ;
    语句2 ;
    ….

    语句n ;
  }

   for
语句的实施各种是:首先实施“起初化语句”;然后测试“条件语句”;若条件建立,则履行语句1到语句n;然后实施“控制”语句;接着再测试条件语句是否创立,假诺成立则另行执行以上过程,直至条件不创制时才截止for循环。

35、 Java 内存模型

2.1 Java 内存模型的基本原理

Java 内存模型,由于 Java
被设计为跨平台的言语,在内存管理上,显著也要有一个合并的
模型。系统设有一个主内存 (Main Memory) , Java
中具备变量都储存在主存中,对于持无线程都是共享的
每条线程都有投机的干活内存 (Working
Memory)
行事内存中保存的是主存中某些变量的正片,线程对具备变量的操作都是在干活内存中举行,线程之间无法互相直接访问,变量传递均需要通过主存完成。

因为当线程处于不同的cpu中时,它各自的变量保存在个别cpu的寄存器或者高速缓存中,这样回事的变量对于另外线程暂时不可见。

 

2.2 Volatile 的内存工作规律

Volatile 是承保两个线程之间变量可见性的,也就是说一个线程对变量举办了写操作,其它一个线程能够拿走它最新的值。

它的做事原理是,它对写和读都是直接操作工作主存的。(那个可以因而操作字节码看到)

 

2.3 Synchronized 的内存操作模型 :

Synchronized,
有两层语义,一个是排斥,一个是可见性。在可见性下边,它的劳作规律有点不同:当线程进入同步块时,会从主存里面获取最新值,然后当线程离开同步块时,再把变量的值更新到主存。

http://tomyz0223.iteye.com/blog/1001778

 

36.刨除一个文本夹内的具有文件和文书夹

 

  1. File file = new File(imgPath);  
  2. if (!file.exists()) return;  
  3. deleteDirectory(file);  
  4.   
  5.   
  6. public void deleteDirectory(File path) {  
  7.             if( path.exists() ) {  
  8.                   File[] files = path.listFiles();  
  9.                   for(int i=0; i<files.length; i++) {  
  10.                          if(files[i].isDirectory()) {  
  11.                            deleteDirectory(files[i]);  
  12.                          }  
  13.                          else {  
  14.                            files[i].delete();  
  15.                          }  
  16.                   }  
  17.             }  
  18.       }  

 

37、关于JSP中的pageContext:

 

应用pageContext所设定的习性对象,其共享范围限于同一个JSP页面

选择request所设定的性能对象,其在同一个request处理期间可以共享(包括forward给其余JSP页面),

session对象所设定的属性对象则避免同一个过程效能期间可以共享,

而application对象所设定的习性,则在所有Web应用程序中的JSP页面都得以共享。

 

 38,Final的初阶化

 1.  final修饰的分子变量没有默认值 
2.  final开始化可以在五个地点 
    (1)阐明的时候起始化 
    (2)构造函数里起初化 
   
(3)即便没有static修饰的话可以在非静态块里起首化,倘若有static修饰的话可以在静态块里发轫化 
3. 
行使final成员前要力保已经起始化,倘若没起先化,或者起首化多次,则不可以通过编译。

 

 39、一些转换技术

  1. Map<String, HandlerMapping> matchingBeans =  
  2.                 BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);  
  3.   
  4.     //map转换list  
  5.     List<HandlerMapping> handlerMappings = new ArrayList<HandlerMapping>(matchingBeans.values());  
  6.       
  7.     //map判断空  
  8.     if (!matchingBeans.isEmpty())  
  9.       
  10.     //数组转List (interceptors 数组)  
  11.     interceptorList.addAll(Arrays.asList(this.interceptors));  
  12.       
  13.     //List转指定对象数组  
  14.     interceptors = this.interceptorList.toArray(new HandlerInterceptor[this.interceptorList.size()]);  

 

40、java.lang.Number是怀有基础项目标父类

  1. public abstract class Number implements java.io.Serializable {  
  2.       
  3.     public abstract int intValue();  
  4.       
  5.     public abstract long longValue();  
  6.       
  7.     public abstract float floatValue();  
  8.       
  9.     public abstract double doubleValue();  
  10.       
  11.     public byte byteValue() {  
  12.     return (byte)intValue();  
  13.     }  
  14.       
  15.     public short shortValue() {  
  16.     return (short)intValue();  
  17.     }  
  18. }  

 

  1. public final class Long extends Number implements Comparable<Long>   
  2.   
  3. public final class Integer extends Number implements Comparable<Integer>   

 

 41、JDK、JRE、JVM

JDK:Java Development ToolKit

Java开发工具包

 

JRE:Java Runtime Environment

Java运行条件

 

JVM:Java Virtual Machine

Java虚拟机

 

 

JDK是SUN集团发布的用于付出Java程序的工具包

在它的bin目录下有很多工具,常见的不外乎:javac.exe,java.exe,javadoc.exe等(其中有成千上万都是用Java编写的)各个本子的IDE工具也是内需使用JDK来完成编译,打包,运行等各样效率的。

 

JRE顾名思义,java的周转条件

JDK是开发工具,在它的安装目录下富含了JRE目录,其实在装置JDK时(1.4本子以上),有一个设置选项,假诺勾上时,在Java的装置目录下会多一个JRE目录,这里的JRE与JDK下的JRE目录基本上是完全一致的,那么为何需要五个JRE呢?

 

前方早已关系过,JDK的bin目录下的重重工具都是用Java编写的,使用这一个工具的时候也是急需周转环境的,通过那多少个.exe包装器(这一个包装器提供了追寻tools.jar中的一些java类的短平快方法,不需要输入一长串的包名和类名)来行使那么些工具时,java会自行检索父目录下的JRE,所以在此间放置了JRE。

 

JVM:Java虚拟机,在window下作为动态连接库(jvm.dll)存在,用于解释施行Java字节码。

可以把它知道成是特意用来举行Java程序的一台机器。也就是说JVM提供了Java执行的硬件平台。JVM上推行的代码都存放在.CLASS文件中。JVM只进行字节码文件。

 

 42、finalize()

Java 技术允许应用 finalize()方法在垃圾收集器将对象从内存中革除出去此前做必要的清理工作。

其一措施是由垃圾收集器在确定这些目的没有被引用时对这么些目标调用的。它是
Object 类中定义的
,因而所有的类都继承了它。子类覆盖 finalize()方法以盘整系统资源或者执行此外清理工作。

finalize() 方法是在垃圾收集器删除对象此前对这么些目标调用的。

垃圾堆收集器只略知一二释放这一个由new分配的内存,所以不领悟怎么着释放对象的“特殊”内存。为釜底抽薪这多少个题材

 

Java提供了一个名为finalize()的模式,它的干活原理应当是如此的:假如垃圾收集器准备好释放对象占用的蕴藏空间,它首先调用finalize(),而且唯有在下几回垃圾收集过程中,才会真的回收对象的内存

就此一旦运用finalize(),就足以在垃圾堆收集期间开展部分重点的消除或清扫工作(如关闭流等操作)。但JVM(Java虚拟机)不保证此措施总被调用。

 

43、原子操作AtomicInteger

  1. public class AtomicLong extends Number  
  2.                 implements Serializable  

API 

J2SE 5.0提供了一组atomic class来援助我们简化同台处理

着力工作规律是行使了同步synchronized的方法实现了对一个long, integer,
对象的增、减、赋值(更新)操作
. 比如对于++运算符,
AtomicInteger可以将它有着的integer 能够atomic
地递增。在需要拜访五个或五个以上
atomic变量的程序代码(或者是对单纯的atomic变量执行多少个或多个以上的操作)通常都亟待被synchronize以便双方的操作可以被当做是一个atomic的单元。 

  1. addAndGet(long delta)   
  2.     //以原子形式将给定值添加到当前值。  
  3.   
  4. getAndSet() :   
  5.     //设置新值,再次来到旧值.   
  6.   
  7. compareAndSet(expectedValue, newValue) :   
  8.     //如若当前值 == 预期值,则以原子模式将该值设置为给定的更新值  
  9.     //假诺更新成功,再次回到true, 否则赶回false  
  10.     //换句话可以这样说: 将原子变量设置为新的值, 可是一旦从本人上次看来的这多少个变量之后到方今被其余线程修改了(和自己希望看到的值不符), 那么更新败北   
  11.     /*  单线程下, compareAndSet重临永远为true,       
  12.      *  多线程下, 在与result举行compare时, counter可能被其他线程set了新值, 这时急需重新再取一遍再相比,       
  13.      *  借使如故不曾拿到新型的值, 则从来循环下去, 直到拿到最新的不行值  
  14.     */  

 

为了加强性能,AtomicLong等类在落实协同时,没有用synchronized关键字,而是直接运用了最低层(地点c语言实现代码)来形成的,

由此你是看不到用synchronized关键字的.

譬如:AtomicLong类中原子操作方法:

public final boolean compareAndSet(long expect, long update) ;

尽管直接行使SUN公司低层本地代码的原子方法(native方法):

public final native boolean compareAndSwapLong(…)来贯彻的.

 

 

44、Object、String类中equals方法的例外

StringBuffer / StringBuilder的equals方法都是持续的Object方法

String类中对equals方法举办了重写

 

Object类的equals方法的实现:

  1. public boolean equals(Object obj) {  
  2.     return (this == obj);  
  3. }  

 Object中的equals就是用==来相比较当前目标和传播的参数的。

再看看String的equals实现

  1. public boolean equals(Object anObject) {  
  2.     if (this == anObject) {  
  3.         return true;  
  4.     }  
  5.     if (anObject instanceof String) {  
  6.         String anotherString = (String)anObject;  
  7.         int n = count;  
  8.         if (n == anotherString.count) {  
  9.         char v1[] = value;  
  10.         char v2[] = anotherString.value;  
  11.         int i = offset;  
  12.         int j = anotherString.offset;  
  13.         while (n– != 0) {  
  14.             if (v1[i++] != v2[j++])  
  15.             return false;  
  16.         }  
  17.         return true;  
  18.         }  
  19.     }  
  20.     return false;  
  21. }  

 它去相比内容了。

再看StringBuilder,在其源码里不曾发觉equals方法,那么它就延续了Object的贯彻,用==来相比传进来的参数。

咱俩来看equals是个实例方法(非static),实例方法是可以被子类重写而去实现协调想要的表现的,因而,无法轻易的说equals就是相比内容的,其一言一行是一定于贯彻的。但==确实是相比地址的。因为java中不协理(至少现在不帮忙)运算符重载,我们不可能改变==的含义,其行事是一定死的。

记念下次毫无说“==相比较地址,equals比较内容”这样的话了,如果要说,也在面前加上一定的准绳,如“假使相比String”,勿断章取义

 

 45、不借助中间变量互换元素

  1. a = a + b  
  2. b = a – b   
  3. a = a – b   

 

46.UUID

UUID(Universally Unique Identifier)

大局唯一标识符

是指在一台机械上生成的数字,是1.5中新增的一个类,在java.util下,用它可以爆发一个名为全球唯一的ID

服从开放软件基金会(OSF)制定的标准计量,用到了以太网卡地点、飞秒级时间、芯片ID码和诸多或者的数字。

由以下几有些的三结合:当前几日子和岁月(UUID的首先个部分与时间关于,倘诺你在转移一个UUID之后,过几秒又变更一个UUID,则率先个部分不同,别的一律),时钟序列,全局唯一的IEEE机器识别号(假如有网卡,从网卡得到,没有网卡以其他措施拿到),UUID的唯一缺点在于转变的结果串会相比较长。 

 

JDK1.5 

只要应用的JDK1.5的话,那么生成UUID变成了一件简单的事,以为JDK实现了UUID: 

java.util.UUID,直接调用即可. 

String s = UUID.randomUUID().toString();  

 

UUID是由一个十六位的数字组合,表现出来的款式诸如 

550E8400-E29B-11D4-A716-446655440000   

 

47、获取随机数

法1:

  1. int num = getRandom(1000);  
  2.     
  3. public static int getRandom(int num) {  
  4.     return (int) Math.round(Math.random() * num);  
  5. }  

 API:

double java.lang.Math.random()

//Returns a double value greater than or equal to 0.0 and less
than 1.0

 

long java.lang.Math.round(double a)

 

 

法2:

  1. Random random = new Random();  
  2. int num = random.nextInt(50);  

 API:

int java.util.Random.nextInt(int n)

//Returns a int value between 0 (inclusive) and the specified
value
 (exclusive), 

 

公共艺术:

  1. public static final String allChar = “023456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZ”;  
  2.     public static final String numberChar = “023456789”;  
  3.   
  4.     /* 
  5.      * 获取随机字符串 
  6.      */  
  7.     public static String generateString(int length){  //参数为回去随机数的尺寸  
  8.         StringBuffer sb = new StringBuffer();  
  9.         Random random = new Random();  
  10.         for (int i = 0; i < length; i++) {  
  11.             sb.append(allChar.charAt(random.nextInt(allChar.length())));  
  12.         }  
  13.         return sb.toString();  
  14.     }  
  15.       
  16.     public static String generateNumber(int length){  //参数为回去随机数的长度  
  17.         StringBuffer sb = new StringBuffer();  
  18.         Random random = new Random();  
  19.         for (int i = 0; i < length; i++) {  
  20.             sb.append(numberChar.charAt(random.nextInt(numberChar.length())));  
  21.         }  
  22.         return sb.toString();  
  23.     }  

 

 48、request.getParameterMap()

在servlet中GET请求可以经过HttpServletRequest的getRequestURL方法和getQueryString()得到完整的伸手路径和呼吁所有参数列表,

POST的内需getParameterMap()方法遍历得到,

随便GET或POST都足以因此getRequestURL+getParameterMap()来拿到请求完整路径

 

request.getParameterMap()的回到类型是Map类型的靶子,也就是顺应key-value的应和关系,但此处要注 

意的是,value的品类是String[],而不是String. 

得到jsp页面提交的参数很容易,但通过它可以将request中的参数和值变成一个map,以下是将赢得的参数和值 

打印出来,形成的map结构:map(key,value[]),即:key是String型,value是String型数组。 

比如:request中的参数t1=1&t1=2&t2=3 

形成的map结构: 

key=t1;value[0]=1,value[1]=2 

key=t2;value[0]=3 

如果一贯用map.get(“t1”),拿到的将是:Ljava.lang.String;
value只所以是数组形式,就是制止参数名有同等的 

情况。 

  1. public class ParamsUitl {  
  2.   
  3.     public static Map<String, String> getParamsMap(HttpServletRequest request) {  
  4.         Map<String,String> params = new HashMap<String,String>();  
  5.         Map requestParams = request.getParameterMap();  
  6.         for (Iterator iter = requestParams.keySet().iterator(); iter.hasNext();) {  
  7.             String name = (String) iter.next();  
  8.             String[] values = (String[]) requestParams.get(name);  
  9.             String valueStr = “”;  
  10.             for (int i = 0; i < values.length; i++) {  
  11.                 valueStr = (i == values.length – 1) ? valueStr + values[i]  
  12.                         : valueStr + values[i] + “,”;  
  13.             }  
  14.             valueStr = new String(valueStr);  
  15.             params.put(name, valueStr);  
  16.         }  
  17.         return params;  
  18.     }     
  19. }  

 

 49.特殊字符过滤

  1. private String formatString(String oldStr){  
  2.         String regEx=”[`~!@#$%^&*()+=|{}’:;’,\\[\\].<>/?~!@#¥%……&*()——+|{}【】‘;:”“’。,、?\r\n|\r|\n|\n\r]”;    
  3.         Pattern   p   =   Pattern.compile(regEx);       
  4.         Matcher   m   =   p.matcher(oldStr);       
  5.         return m.replaceAll(“”).trim();  
  6.     }  

 

 

 

易错题:

1、

  1. int j = 0;  
  2.         j = j++;  
  3.         System.out.println(j);  

 没见过此题的人,大部分人或许得到的结果是:1。
但是,运行的结果会令你彻底失望。那是哪些原因呢?原来Java编译器处理后缀++或–时是这么处理的:java的编译器在遭遇j++和j-
-的时候会再次为变量运算分配一块内存空间,以存放原始的值,而在成就了赋值运算之后,将这块内存释放掉。即JAVA先将j的值保存到临时内存空间中,然
后甩卖++,即原来的j加1,此时本来的j变成1,然后再实践赋值,将内存空间中所存放的本来的值赋回给j,所以j仍旧是0。C#和Java的结果是一样
的。

反倒,C/C++不是如此处理的:C中是透过寄存器作中转先把j的值赋给它自身,再实践++的操作,这样结果就是1了。

2、

  1. String a = “abc”;     
  2.         String b = “abc”;     
  3.         System.out.println(“====>”+ a==b ); //”+”的先行级比”==”高,实际相比较的是”====>abc”与abc  false  
  4.         System.out.println(“====>”+ (a==b) );                    //true  

 

3、一眼能表露它的结果

 

  1. public class MainTest {  
  2.   
  3.     public static void main(String[] args) {  
  4.         String s = null;    
  5.         s = s+”word”;    
  6.         System.out.println(“hello ” +s);    
  7.     }  
  8.   
  9. }  

 结果:hello nullword

  1. String s = null;      
  2.         //s = s+”word”;      
  3.         System.out.println(“hello ” +s);   
  4.   
  5. //结果:hello null  

 

 

 

抽象类中可以有抽象方法和非抽象方法 !

 

构造方法可以被重载,但不可以被重写

 

数组没有 length() 那个措施,有 length 的特性。 String 有有 length() 这多少个艺术。

 

  1. Scanner scanner = new Scanner(System.in);  
  2.  String temp = scanner.nextLine();  
  3.  System.out.println(“temp==”+temp);  

 

 

 

new String(name.getBytes(“iso-8859-1″),”utf-8”);

 

 

其他:

 java类成员变量在没有赋值的时候会赋以默认值,其它一些变量是不可知享用这种待遇的。

Post Author: admin

发表评论

电子邮件地址不会被公开。 必填项已用*标注