精华内容
下载资源
问答
  • Java读取图片像素和大小

    万次阅读 2015-07-09 11:37:28
    package com.aa.promotion.dao.generalize; import java.awt.image.BufferedImage; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOExcep
    package com.aa.promotion.dao.generalize;
    


    import java.awt.image.BufferedImage;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.nio.channels.FileChannel;


    import javax.imageio.ImageIO;


    public class UmpGeneralizeDAO {


    public static void main(String[] args) {
    File file = new File("E:\\test.jpg");
    FileChannel fc = null;
    if(file.exists() && file.isFile()){
    try {
    FileInputStream fs = new FileInputStream(file);
    fc = fs.getChannel();
    System.out.println(fc.size() + "-----fc.size()");
    } catch (FileNotFoundException e) {
    e.printStackTrace();
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    System.out.println(file.length() + "-----file.length  B");
    System.out.println(file.length() * 1024 + "-----file.length  kb");
    BufferedImage bi = null;
    try {
    bi = ImageIO.read(file);
    } catch (IOException e) {
    e.printStackTrace();
    }

    int width = bi.getWidth();
    int height = bi.getHeight();

    System.out.println("宽:像素-----" + width + "高:像素"  + height);


    }
    }


    获取到的图片大小默认为B
    展开全文
  • java读书笔记

    千次阅读 2016-06-18 19:22:49
    1.豆芽它长房高,它也是根菜! 2.要么就轰轰烈烈的活着。,要么就安安静静的死去! ...java日期类型转换: try { DateFormat format = new SimpleDateFormat("yyyy-MM-dd"); String ...

    1.豆芽它长房高,它也是根菜!

     

    2.要么就轰轰烈烈的活着。,要么就安安静静的死去!

     

    3.程序员这一行有三个点在支撑,技术、管理(管理自己的时间和精力)、与人沟通。

     

    4.自动类型转换:

     

    java日期类型转换:

     

     

    try {

    DateFormat format = new SimpleDateFormat("yyyy-MM-dd");

    String sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());

    Timestamp ts = new Timestamp(format.parse(sdf).getTime());

    System.out.println(sdf);

    } catch (ParseException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

     

     

     

     

    1.在Java开发中,控制台输出仍是一个重要的工具。Java对应的“标准输入”、“标准输出”、“标准错误输出”的概念提供了相应的System.in、System.out、System.err。在Java命令行编程时,经常要用到标准输入输出,在PC上标准的输入就是指从键盘输入,标准的输出就是显示器输出。System.out已经封装成一个PrintStream对象,未进行任何处理。这意味着尽管能直接使用System.out和System.err,但是需要对System.in进行一定的封装,使用起来才会比较方便。

    System.out.print,  System.err.print     输出一个字符串,不换行

    System.out.println, System.err.println   输出一个字符串,换行

    System.in.read                      从输入中读一个字节

    System.in.skip(long  n)               在输入中跳过n个字节

     

    2.foreach的用法:

    import java.util.*;

    public class TestArrays

    {

    public static void main(String[] args)

    {

    int[] a = {3, 4, 5, 6};

    int[] a2 = {3, 4, 5, 6};

    System.out.println("a数组和b数组是否相等:" + Arrays.equals(a, a2));

    int[] b = Arrays.copyOf(a, 6);

    for (int i : b)

    {

    System.out.print(i + " ");  //注意这里输出数组b的元素用参数i,而不是b[i];

    }

    System.out.println();

    System.out.println("b数组的元素为:" + Arrays.toString(b));  //疯 p_102

    }

    }

     

     

    3.初始化块虽然也是java类的一种成员,但他没有名字,也就没有标识,因此无法通过类、对象来调用初始化块,初始化块只在创建java对象时隐式执行,而且在执行构造器之前执行。

     

    4.系统中静态初始化块总是比普通初始化块先执行,静态初始化块是类相关的,用于对整个类进行处理,通常用于对类属性执行初始化处理,静态初始化块不能对实例属性进行初始化处理。

     

       类中静态初始化块、非静态初始化块、和类的构造器的执行顺序是:静态初始化快、非静态初始化块、构造器。

        

        对于局部变量(方法内部定义的变量)而言,其作用域就是它所在的方法,不可能被其他类来访问,因此不能使用方法控制符来修饰(private、public protect等);并且局部变量除了形参之外,都必须显示初始化。也就是说,必须先给方法局部变量和代码块局部变量指定初始值,否则不可以访问他们。

     

        在同一个类里成员变量的作用范围是整个类内有效,一个类里不能定义两个同名的成员变量,即使一个是类属性,一个是实例属性也不行;一个方法里不能定义两个同名的局部变量,即使一个是方法局部变量,一个是代码块局部变量或者形参也不行。

     

    5.通过super在子类中调用父类被覆盖的方法的格式为:super.方法名(参数类表);在子类中调用父类的构造器的格式为:super(父类构造器的参数列表);

     

    6.                         访问控制符的级别表

     

    private

    Default(默认)

    protected

    public

    同一个类中

    可以

    可以

    可以

    可以

    同一个包中

     

    可以

    可以

    可以

    子类中

     

    在同一个包中可以访问

    在不同包中不能访问(已验证)

    可以

    可以

    全局范围内

     

     

     

    可以

     

    7.如果一个java源文件里定义的所有类都没有使用public修饰,则这个java源文件的文件名可以是一切合法的文件名,但如果一个java源文件里定义了一个public修饰的类,则这个原文进的文件名必须与public类的类名相同。

     

    8.Java默认为所有源文件导入java.lang包下的所有类,因此前面在java程序中使用String/、System类时都无须使用import语句来导入这些类,但对于前面介绍数组时提到的Array类,其位于java.util包下,则必须使用import语句来导入该类。

     

    9.通常建议为java类保留无参数的构造器,因此,如果为一个类编写了有参数的构造器,通常建议为该类额外编写一个无参数的构造器。

     

    10.在一个类中,如果一个构造器完全包含于(代码完全相同)该类的另一个构造器中,就可以通过this来调用 该构造器,格式为:this(被调构造器的形参列表)。

     

    11.多态:

    class BaseClass

    {

    public int a = 6;

    public void base()

    {

    System.out.println("父类的普通方法!");

    }

    public void test()

    {

    System.out.println("父类被覆盖的方法!");

    }

    }

    public class SubClass extends BaseClass

    {

    public String a = "子类覆盖父类的属性!";

    public void sub()

    {

    System.out.println("子类的普通方法!");

    }

    public void test()

    {

    System.out.println("子类重写父类的方法!");

    }

    public static void main(String[] args)

    {

    BaseClass A = new BaseClass();  //声明一个BaseClass类的对象 

    A.base();

    A.test();

    SubClass B = new SubClass();

    System.out.println("子类的属性:" + B.a);

    B.sub();

    B.test();

    BaseClass C = new SubClass();

    System.out.println("C对象的属性:" + C.a);  //父类的属性

    C.base(); //调用父类的普通方法     //父类的普通方法

    C.test();  //不知道是该调用父类的test方法还是子类的test方法  //子类重写父类的方法

    //C.Sum();//调用子类的普通方法

    System.out.println("向下转型:");

    if(new BaseClass() instanceof SubClass)  //将父类对象赋给子类(向下转型)用instanceof运算符

    //判断是否可以转型成功,从而避免ClassCastException异常,这样可以保证程序更加健壮。

     

    {

    System.out.println("转型成功!");

    SubClass D = (SubClass)new BaseClass();  //向下转型

    System.out.println("将父类对象赋给子类对象(向下转型:)" + D.a);

    D.base();

    D.test();

    //D.Sub();

    }

    else

    {

    System.out.println("转型失败!");

    }

     

    }

    }

    解析:BaseClass C = new SubClass();  这一条语句比较特殊,他的编译类型是BaseClass,而运行时类型是SubClass,当调用该引用变量的test方法时(BaseClass类中定义了该方法,子类SubClass覆盖了父类的该方法),实际执行的是SubClass类中覆盖后的test方法,这就是多态。

    当运行该引用变量(此处为C)时,其方法行为总是像子类方法的行为,而不是像父类方法的行为,与方法不同的是,对象的属性则不具备多态性,即通过引用变量来访问其包含的实例属性时,系统总是试图访问它编译时(此处为BaseClass)类所定义的属性,而不是它运行时类所定义的属性。

    因为子类其实是一种特殊的父类,因此java允许把一个子类对象直接赋给一个父类引用变量,无需任何类型转换,或者被称为向上转型。向上转型是由系统自动完成的。但把一个父类对象赋给子类引用变量时,就需要进行强制类型转换,而且还可能在运行时产生ClassCastException异常,使用instanceof运算符可以让强制类型转换更安全。

     

    12.利用组合实现复用:对于继承而言,子类可以直接获得父类的public方法,程序使用子类时,将可以直接访问该子类从父类那里继承道德方法,而组合则是把旧类(不能说成是父类,因为组合的两个类之间没有继承关系)对象作为新类的属性嵌入,用以实现新类的功能,用户看到的是新类的方法,而不能看到嵌入对象的方法,因此,通常需要在新类里使用private修饰嵌入旧类对象。例如(《疯狂java讲义》 P157).

     

    13.String类型与基本数据类型之间的转换:

     

    public class Primitive2String

    {

    public static void main(String[] args)

    {

    String str = "123";

    int it = Integer.parseInt(str);  //把一个特定字符串转换成int变量

    System.out.println(it);

    String flot = "12.2";

    //把一个字符串转换成float变量

    float ft = Float.parseFloat(flot);

    System.out.println(ft);

    //把一个float变量转换成String变量

    String ftstr = String.valueOf(2.123f);  //这里要加f,否则会被默认为double型。

    System.out.println(ftstr);

    //把一个double变量转换成String变量

    String strdb = String.valueOf(2.344);

    System.out.println(strdb);

    }

    }

    注意:如果希望把基本类型转换成字符串,还有一种更加简单的方法,将基本类型变量和“ ”进行连接运算,系统会自动把基本类型转换成字符串,例如:

     

     

    //intStr的值为“5”

    String intStr = 5 + "";

     

     

    基本类型变量和String之间的转换:

     

    例如:public class Primitive2Wrapper

    {

    public static void main(String[] args)

    {

    boolean b1 = true;

    //通过构造器把b1基本类型变量包装成包装类对象

    Boolean b1Obj = new Boolean(b1);

    System.out.println(b1Obj);  //输出true

    int it = 5;

    //通过构造器把it基本类型变量包装成类对象

    Integer itObj = new Integer(it);

    System.out.println(itObj);  //输出5

    //把一个字符串转换成Float对象

    Float f1 = new Float("4.56");

    System.out.println(f1);  //输出4.56

    //把一个字符串转换成Boolean对象

    Boolean bObj = new Boolean("false");

    System.out.println(bObj);  //输出false

    //下面程序运行时将出现java.lang.NumberFormatException异常

    Long lObj = new Long("ddd");  //这是由字符串不能成功转换成基本类型变量引起的

    }  

    }

     

    1.抽象类不能用来创建实例,只能被当做父类被其他子类继承。

    当abstract修饰类时,表明这个类只能被继承,当abstract修饰方法时,表明这个方法必须由子类提供实现(即重写)。而final修饰的类不能被继承,final修饰的方法不能被重写。因此final和abstract永远不能同时使用。除此之外,当使用static来修饰一个方法时,表明这个方法属于当前类,即该方法可以通过类来调用,如果该方法被定义成抽象方法,则将通过该类来调用该方法时出现错误(调用了一个没有方法体的方法肯定会引起错误),因此static和abstract不能同时修饰某个方法,既没有所谓的类抽象方法。

    Abstract关键字修饰方法必须被其子类重写才有意义,否则这个方法将永远不会有方法体,因此,abstract方法不能定义为private访问权限(否则子类不能重写该方法的方法体),即private和abstract不能同时使用。

     

    2.接口只能继承接口不能继承类,接口里可以包含属性(只能是常量)、方法(只能是抽象实例方法)、内部类(包括内部接口)和枚举类。接口里的所有成员,包括常量、方法、内部类和枚举类都是public访问权限(系统默认)。在接口中定义属性时,不管是否使用public static final修饰符,接口里的属性总将使用这三个修饰符来修饰。而且,接口里没有构造器和初始化块,因此接口里定义的属性只能在定义时指定默认值。

     

    3.一个类实现一个或多个接口之后,这个类必须完全实现这些接口里所定义的全部抽象方法,(也就是重写这些抽象方法);否则,该类将保留从父类接口那里继承到的抽象方法,该类也必须定义成抽象类。

     

    4.实现接口方法时,必须使用public访问控制修饰符,因为接口里的方法都是public的,而子类(相当于实现类)重写父类方法时访问权限只能更大或者相等,所以实现类实现接口里的方法时只能使用public访问控制权限。

     

    5.接口和抽象类在用法上也存在差别:

    ① 接口里只能包含抽象方法,不包含已经提供实现的方法,抽象类则完全可以包含普通方法。

    ② 接口里不能定义静态方法:抽象类里可以定义静态方法。

    ③ 接口里只能定义静态常量属性,不能定义普通属性,抽象类里则既可以定义普通属性,也可以定义静态常量属性。

    ④ 接口不包含构造器;抽象类里可以包含构造器,抽象类里的构造器并不是用于创建对象,而让其子类调用这些构造器来完成属于抽象类的初始化操作。

    ⑤ 接口里不能包含初始化块,但抽象类则完全可以包含初始化块。

    ⑥ 一个类最多只能有一个直接父类,包括抽象类;但一个类可以直接实现多个接口,通过实现多个接口可以弥补Java单继承的不足。

     

    18.switch语句的用法:

    public class test

    {

    public static void main(String[] argsk)

    {

    test t = new test();

    t.tee(4);

     

    }

    void tee(int i)

    {

     

    switch(i)

    {

    default:

    System.out.println("不设置");

     

    case 1:

    System.out.println("输出1");

    case 2: 

    System.out.println("输出2"); break;

     

    }

    }

    }

    注意:default放在前面会出现问题。

    输出结果为:

    不设置

    输出1  //这里执行case2是因为case1后面没有break;

    输出2

    如果上面程序case1后面加上break,则输出结果为:

    不设置

    输出1

    总结:switch中的case与default可以互换位置,但不论如何,只有最后一个case或default才可以省略break,前面的语句必须加break,否则程序会执行下面的语句,也就是break与case并没有什么特殊之处。

     

    20.import可以想某个java文件中导入指定包层次下某个类或全部类,import语句应该出现在package语句(如果有的话)之后、类定义之前。一个java源文件只能包含一个package语句,可以包含多个import语句,多个import语句用于导入多个包层次下的类。Java默认为所有源文件导入java.lang包下的所有类。

     

    21.静态导入语句使用import static语句,用于导入指定类的单个静态属性和全部静态属性。

     

    22.介绍数组时提到Arrays类,其位于java.util包下,则必须使用import语句来导入该类。

     

    23.普通方法可以调用静态变量或静态方法,但静态方法调用普通方法或普通变量时必须创建对象来调用,否则,静态成员是不能引用非静态成员的。

     

    24.在构造其中既可以调用该类的静态成员也可以调用该类的非静态成员,但调用时都必须使用this来调用(其中this在该类的其他地方可以省略,但在构造器中不可省)。

     

    25.注意:构造器不能用static来修饰;

     

    26.类的组合:

    class person

    {

    protected void breath()

    {

    System.out.println("我贪婪的呼吸这清新的空气!感觉真爽");

    }

    void heart()

    {

    System.out.println("我心跳的快从胸膛里蹦出来了!");

    }

    }

     class brid

    {

    private person a ;  //通常需要在新类里使用private修饰嵌入旧类的对象

    public brid(person a)

    {

    this.a = a;

    }

    public void brea()

    {

    a.breath();

    }

    public void heart()

    {

    a.heart();

    }

    }

     

    class aaa

    {

    public static void main(String[] args)

    {

    person d = new person();

    brid A = new brid(d);

    A.brea();

    A.heart();

    }

    }

     

     

    27.经典的仅用两个数据本身进行互换操作:int x = 3; int y = 4; x = x + y; y = x - y; x = x -y;仅 用这三条语句就可以实现两个数的互换而不用第三个变量参与。

     

    28.在java中,类的成员变量既可以赋初值,也可以不赋初值,当不赋初值时,系统会自动给该变量赋相应系统默认的初值(因为系统默认的构造函数会自动初始化该类中的成员变量),但java中的局部变量必须先赋初值然后在使用。

     

    29.在重载方法时,如果两个方法的参数列表完全相同,只有方法的返回值不同,这样不会构成重载(而是方法的重名),因为调用方法时不会检测方法的返回值类型,此时调用方法会产生二义性,因而编译时系统会报错说重复定义了该方法。

     

    30.当一个变量名有多处声明,在使用时不知道当前变量属于哪一个声明时,找跟它最近的一个声明,这就是最近声明原则。

     

    31.局部变量在栈(stack)内存中分配,成员变量在堆(heap)内存中分配,静态变量在数据区(data seg)中分配,代码在代码区存放。当创建一个类的多个对象时,该类的实例变量成员会创建多份并存放在堆内存中,但是该类的静态类变量和该类的方法(不论类方法或实例方法都只有一份存放在代码区(code seg))。

     

    32.如果想将一个类放入包中,在这个类源文件第一句话写package,必须保证该类的class文件位于正确的目录下(注意:该类的源码可能会产生影响,所以当该类的源文件经编译产生.class文件后,将源文件(即.java文件)删除或转移到另外的目录下)。

     

    33.将自己的java程序打成一个jar包的方法:在当前工作路径下,输入jar -cvf 跟上生成jar包的名字子 *.* ,(*.*的意思是将当前目录下的所有目录及子目录全部打包到jar包当中。)

     

    34.如下是将自己的文件打成jar包并导入其他java文件中的例子:

    将自己的Dog.java自动生成文件夹层次的命令:javac -d . Dog.java(注意:这里要设置环境变量classpath:)

    G:\java>javac -d . Dog.java

     

    G:\java>java Dog

    Exception in thread "main" java.lang.NoSuchMethodError: main

     

    G:\java>set classpath = %classpath%;g:\java\;

     

    G:\java>java qq807882379.myjava.Dog

    xiaogougou!

    将刚才生成的文件夹打成jar包的命令(lijunjun为jar包的包名):

    G:\java>jar -cvf lijunjun.jar qq807882379.*

    标明清单(manifest)

    增加:qq807882379/(读入= 0) (写出= 0)(存储了 0%)

    增加:qq807882379/myjava/(读入= 0) (写出= 0)(存储了 0%)

    增加:qq807882379/myjava/Dog.class(读入= 430) (写出= 303)(压缩了 29%)

     

    G:\java>javac -d . Dog.java

     

    G:\java>java qq807882379.myjava.Dog   (这里调用的是jar包中的Dog.class)

    xiaogougou!

    当在其他文件中要导入指定的jar包是要将该jar包设置在环境变量classpath中,才能在其他java程序中引用。

    G:\java>set classpath=%classpath%;g:\java\lijunjun.jar;

    然后就可以将lijunjun.jar这个jar包导入Cat程序中使用;

    G:\java>javac Cat.java

     

    G:\java>java Cat

    xiaogougoulaichuanmenle!

    xiaomaozaijiadengniwan!

     

    Dog.java程序和Cat.jar程序如下:

    package qq807882379.myjava;

     

    public class Dog {

    public void print() {

    System.out.println("xiaogougoulaichuanmenle!");

    }

    public static void main(String[] args) {

    System.out.println("xiaogougouwolaile!");

    }

    }

     

     

    import qq807882379.myjava.Dog;

    class Cat

    {

    public static void main(String[] args) {

    Dog d = new Dog();

    d.print();

    System.out.println("xiaomaozaijiadengniwan!");

    }

    }

     

    35.当子类继承了父类之后想要重写父类的方法,那么就直接把父类的该方法的函数签名直接从父类复制到子类中,因为重写的条件是方法的返回值、方法名、参数列表要相同。复制粘贴可以防止将父类要重写的方法名在子类中写错,这种情况并不是子类重写了父类的方法,而是子类自己有定义了属于子类自己的方法(这样的错误编译和运行时永远不会报错,很难检查出来!)。并且子类中重写后的方法的访问权限只能同父类的访问权限一样或比父类的访问权限大,绝对不能比父类中该方法的访问权限小。

     

    36.当子类new一个对象出来时,该对象在内存中同时产生了子类的除了该对象名之外的另一个引用this和一个父类的引用super。

     

    37.当在子类构造方法中用super调用父类的构造方法时,必须将super写在子类构造方法的第一行(因为现有父亲才有儿子!)。

     

    38.当编译一个java文件时,java虚拟机会按照classpath设置的路径去寻找你到运行的.class文件,这时如果其他路径下有一个同名的.class文件,而恰好在设置classpath时将.;也就是在当前路径下查找的设置放在了该同名的.class文件的路径后面,则程序在运行时就会运行同名的.class文件,这样程序就会出现意料之外的结果:所以在设置classpath时一定将.;在当前路经下查找设置在第一个,以防出现上面的这种情况,万一出现上面这种情况(即在编译时没有任何问题,可在运行时结果不正确),你可以修改类名来测验。否则这种错误能折腾死人!

     

    39.多态(或动态绑定):动态绑定是指“在执行期间(而非编译期)判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。”多态(或动态绑定)是面向对象编程的核心中的核心。New的是谁就找谁的方法。

     

    40.Final的变量的值不能被改变,final的方法不能被重写,final的类不能被继承。

     

    41.接口中的方法前面不用写abstract,但接口里的所有方法都是abstract的;

     

    42.接口的特性:接口可以多重实现;接口中声明的属性默认为public static final 的,也只能是public static final的; 接口中只能定义抽象方法,而且这些方法默认为public的,也只能是public的;接口可以继承其他的接口,并添加新的属性和抽象方法。

     

    43.接口里的一个问题:接口A里有一个抽象方法getMoney();接口B里有一个抽象方法getMoney();接口C同时继承了接口A和接口B,如果A和B中的getMoney方法的返回值都是同一类型的,则在C中只定义一个getMoney(){}方法即可,该方法在A和B里都可见,当A和B中的两个方法的返回值类型不同,则会出问题,例如:A中getMoney的返回值类型为double型,B中的getMoney的返回值为void类型,这时,在C中又该如何实现A和B中的两个getMoney方法,又该如何区分呢?

    解答:使用内部类,C类中再写一个内部类D,C类中可以实现A接口及A接口中的抽象方法,在C的内部类D中在实现B接口及B接口中的抽象方法。

     

    44.在java中,函数的返回值可以是数组类型:例如:public static Date[] bubbleSort(Date [] a){……};

     

    45.Myeclips工具的一点使用技巧:用鼠标选中一块内容,然后按ctrl+shift+/就可以把这整段给自动注释起来,然后按ctrl+shift+\就可以去掉整段被注释的内容。

     

    46.输入输出流:

    47.在创建一个窗口时,如果没有设置关闭事件,则只能在dos窗口的命令行敲Ctrl + C来退出刚创建的窗口。

     

    48.在一个类的内部声明的类叫内部类,在一个在类的方法里或该类内部的初始化块或if语句块里声明的类叫局部类.

     

    49.Panel类的默认布局管理器为FlowLayout;Frame窗口默认的布局管理器是BorderLayout;

     

    50.在创建多线程时,如果能使用接口就不要从Thread继承,因为接口比较灵活,他可以实现多个接口和继承其他一个父类:

     

    51.在DOS窗口查在当前路径下的全部文件名用 dir ;要查某一类型的文件如.class文件可以用dir *.class来查询。。

     

    52.《TCP\IP详解》;

     

    53.端口号是用来区分同一台机器上的不同应用程序。

     

    54.TCP和UDP各有65536个端口号;

     

    55.当方法里的逻辑比较简单,语句比较少,不经常变动时可以考虑使用匿名类,一般使用内部类就可以了。

     

    56.在那个线程里调用的sleep()方法,就让那个线程睡眠。

     

    57.容器类对象在调用remove、contains等方法时需要比较对象是否相等,这会涉及到对象类型的equals方法和hashCode方法;对于自定义的类型,需要重写equals和hashCode方法以实现自定义的对象相等规则。 注意:相等的对象应该具有相等的hashCode。记住一个原则:你要重写这一对象的equals方法必须重写该对象的hashCode方法。

    import java.util.*;

     

    public class Test {

    public static void main(String[] args) {

    Collection c = new LinkedList();

    c.add("hello");

    c.add(new Name("f1", "l1"));

    c.add(new Integer(100));

    System.out.println(c);

    c.remove("hello");

    System.out.println(c.remove(new Name("f1", "l1"))); //remove的返回类型是boolean型

    System.out.println(c);

    }

    }

    class Name {

    private String firstName, lastName;

    public Name(String firstName, String lastName) {

    this.firstName = firstName;

    this.lastName = lastName;

    }

    public String getFirstName() {

    return firstName;

    }

    public String getLastName() {

    return lastName;

    }

    public String toString() {

    return firstName + " " + lastName;

    }

    public boolean equals (Object obj) {  //这里重写了equals方法

    if(obj instanceof Name) {

    Name name = (Name) obj;

    return (firstName.equals(name.firstName))

    && (lastName.equals(name.lastName));

    }

    return super.equals(obj);

    }

    public int hashCode() {  //同样在这里重写了hashCode方法

    return firstName.hashCode();

    }

    }

     

    58.如何选择数据结构:Array读快改慢;Linked改快读慢;hash两者之间。

     

    59.在命令行窗口上输入一个cls则会将当前命令行窗口清除,以第一行开始。

     

    60.Comparable接口只有用作自己本类的对象之间作比较时才有意义。

     

    61.在API文档中,查找一个只知道函数名称不知道是在那个包的那个类里的函数,可以在API文档的index页面下摁Ctrl+f来搜素,也可以在左上角的索引框中输入你要查找的内容。

     

    62.在MyEclipse中当一个对象后面加一个点时MyEclipse会自动提示,有时提示会自动消失,这时可以按Alt+/提示就会自动显示。

     

    63.Winmerge工具比较前一个版本和后一个版本之间的代码的变动

     

    64.我怎么从键盘输入一个int/double/字符串?
    答: java的I/O操作比C++要复杂一点。如果要从键盘输入,样例代码如下:BufferedReader cin = new BufferedReader( new InputStreamReader( System.in ) );String s = cin.readLine();
    这样你就获得了一个字符串,如果你需要数字的话再加上:int n = Integer.parseInt( s ); 或者 double d = Double.parseDouble( s );

     

    65.关闭资源最严谨的方式为:(首先关闭资源的代码要放在finally块中)例如:

    finally {

    try {

    if(rs != null) {

    rs.close();

    }finally {

    try {

    if(st != null) {

    st.close();

    }

    }finally {

    if(conn != null) {

    conn.close();

    }

    }

    }

    }

    }

     

    66.单例类就是将该类的构造方法定义成private,不允许类外部new该类的实例对象。而在类的内部new一个该类的对象,然后定义一个public方法返回该类new出来的对象作为该类对外部的接口,所以该方法的返回类型为该类的类类型。

     

    67.JavaBean是使用Java语言编写的组件。组件的特点是:能够完成特定的功能,这些功能主要用于共享;是一个大系统的组成部分,不能独立运行,主要目的是供其他文件进行调用。

    注意:在编写JavaBean时一定要注意编程的规范。这里用到的编程的规范有:为类创建一个包,包名通常使用小写,类名首字母大写,类名中每个单词的首字母大写,属性名通常首字母小写;方法名首字母小写;代码的缩进。


    68.java的util类和数据库的sql类中都有getDate()方法,util类中的getDate()方法可以取出日期和时间,而sql类中的getDate()方法,只能取出当前的日期,不能取出当前的具体时间,这就是util类和sql类中getDate()方法的区别。关系是sql中的getDate()方法是从util类中继承下来的。

     

    69.ctrl + 1 可以对java程序中的一个变量全部重命名。

     

     

     

     

     

     

    70.J2EE的三层架构图:

    71.一个类的内部类在该类的静态方法中不能直接new一个该内部类的实例出来,

     

     

    例: class A {

    Public static void main(String[] args) {

    B b = new B();   (错误:不能在静态方法中直接new一个内部类的对象)

    }

    Class B {}

    }

    可以通过在一个方法中new 一个B的对象出来,然后再在静态方法中调用这个方法,就可以解决上面的问题:

    class A {

    Public static void main(String[] args) {

      test();  (通过方法调用解决)

    }

    Class B {}

    Public  void test() {

    B b = new B(); 

    }

    }

     

     

     

     

    //在面板上画出图片

    Image im = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/a3531368.jpg"));

    //上面这句可以用(image1 = ImageIO.read(new File("images/1.gif"));)这一句代替,并且效果更好

     

    //显示图片

    g.drawImage(im, 10, 10, 200, 150, this);

    //如何画出字

    g.setColor(Color.red);

    g.setFont(new Font("华文彩云", Font.BOLD ,30));

    g.drawString("祖国万岁", 100, 120);

     

    一个事件源可以有多个事件监听者。

    在JPanel或者Panel控件中有一个paint(Graphics g)方法,在该方法中必须要写一句:super.paint(g);;如果不写,则画出的图形(在移动的时候会留下痕迹):

    如果加上super.paint(g); 则画出的图形在移动的过程中不会留下痕迹:

     

     

    注意:鼠标的移动和拖拽事件在MouseMotionListener接口中实现监听。

    窗口的最小化、最大化、还原等事件的监听接口为:WindowLinstener ;

     

    在处理键盘的事件响应时应该用e.getKeyCode()==KeyEvent.VK_W来判断哪个键是被按下,而不应该用e.getKeyChar()==KeyEvent.VK_W来判断那个键被按下。

     

    唐骏:人无我有,人有我精,人精我转。

    注意线程的两种启动方式:

    1.extends Thread方式;

    public class Test {

    public static void main(String[] args) {

    Cat cat = new Cat();

    cat.start();

    }

    }

    class Cat extends Thread {

    int times = 0;

    public void run() {

    while(true) {

    try {

    Thread.sleep(1000);

    catch(InterruptedException e) {

    e.printStackTrace();

    }

    times++;

    System.out.println("Hello World!" + times);

    if(times == 10) {

    //退出

    break;

    }

    }

    }

    }

    2.implements Runnable方式:

     

    public class Test2 {

    public static void main(String[] args) {

    Dog dog = new Dog();

    Thread t = new Thread(dog);

    t.start();

    }

    }

    class Dog implements Runnable {

    int times = 0;

    public void run() {

    while(true) {

    try {

    Thread.sleep(1000);

    catch (InterruptedException e) {

    e.printStackTrace();

    }

    System.out.println("hello world " +  times);

    times++;

    if(times == 10) {

    //退出

    break;

    }

    }

    }

    }

     

    例如:

    public class Test4 {

    public static void main(String[] args) {

    Cat cat1 = new Cat();

    //Cat cat1 = new Cat();  //错误:java.lang.IllegalThreadStateException

    cat1.start();

    Dog dog1 = new Dog();

    Thread t = new Thread(dog1);

    Thread t2 = new Thread(dog1);

    t.start();

    //t.start();  //java.lang.IllegalThreadStateException

    t2.start();  //可以

    }

    }

    //猫类

    class Cat extends Thread {

    public void run() {

    System.out.println("11");

    }

    }

    //狗类

    class Dog implements Runnable {

    public void run() {

    System.out.println("22");

    }

    }

    Thread.currentThread().getName();该条语句可以得到当前线程的名字。

    三个窗口买2000张票的程序:

    public class Test {

    public static void main(String[] args) {

    //定义三个售票窗口

    TicketWindow tw1 = new TicketWindow();

    TicketWindow tw2 = new TicketWindow();

    TicketWindow tw3 = new TicketWindow();

     

    Thread t1 = new Thread(tw1);

    Thread t2 = new Thread(tw1);

    Thread t3 = new Thread(tw1);

     

    t1.start();

    t2.start();

    t3.start();

    }

    }

    //售票窗口

    class TicketWindow implements Runnable{

     

    private static int nums = 2000;  //一共2000张票

     

    public void run() {

    while(true) {

    try {

    Thread.sleep(1000);

    catch (InterruptedException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    //认为if else 要保证其原子性

    synchronized(this) {

    //判断是否还有票

    if(nums > 0) {

    //显示售票信息

    System.out.println(Thread.currentThread().getName() + "在售出第" + nums + "张票");

    nums--;

    else {

    //售票结束

    System.out.println("售票结束");

    break;

    }

    }

    }

    }

    }

     

    一个文件的后缀名没有意义,因为可以把一个文本文件修改后缀名为.mp3,但是用记事本打开后依然可以编写文字,但是该文件用mp3播放器却不能播放。

     

    还有一种给文件加密的方法:以视频文件为例,首先用记事本将该视屏文件以二进制文件的形式打开,在某一地方加入几个字母(123),然后保存,之后用视频播放器播放或者任何播放器都不可能打开该文件,因为该文件的文件头已经被破坏,如果想看该文件,依然用记事本打开该文件,删除你加的那几个字母,然后用指定播放器打开该文件,该文件就又可以正常播放了。

     

    经典问题:

    如上图所示:为什么该txt文件大小只占22个字节,去占用4KB的空间。

    答:因为该操作系统分配的硬盘最小块就是4KB,如果该文件的大小大于4KB,则这里所占用的空间就会变为8KB..

     

    较难破译的密码格式:xm@100~cqw

     

    字节流对象可以操作任何类型的文件。

    用程序对文件及文件夹的各种操作:

    /*

     * 功能:File类的基本用法

     */

    package com.test3;;

    import java.io.*;

    public class Test {

    public static void main(String[] args) {

    /*File f = new File("e:/1.txt");

    //得到文件的路径

    System.out.println("文件路径" + f.getAbsolutePath());

    //得到文件的大小(返回的是字节大小)

    System.out.println("文件大小" + f.length());

    //文件是否可读

    System.out.println("可读" + f.canRead());*/

    //创建文件和创建文件夹

    /*File f = new File("e:/2.txt");

    if(!f.exists()) { //判断2.txt文件是否存在

    try {

    f.createNewFile();

    } catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    } else {

    System.out.println("文件已经存在,暂时不能创建!");

    }

    */

    //如何创建文件夹

    /*File f = new File("e:/ljj");

    if(f.isDirectory()) {//判断该文件夹是否已经存在

    System.out.println("文件夹已经存在");

    } else {

    //创建文件夹

    f.mkdir();

    }*/

    //列出一个文件夹下面的所有文件

    File f = new File("g:/java");

    if(f.isDirectory()) {//判断如果f是一个文件夹

    File[] lists = f.listFiles();

    for(int i=0; i<lists.length; i++) {

    System.out.println("文件名 :" + i + "--" + lists[i].getName());

    }

    }

    }

    }

    从文件中读取内容到控制台打印出来:

    /*

     * 使用FileInputStream从文件中读入内容

     */

    package com.test4;

    import java.io.*;

    public class Test {

     

    public static void main(String[] args) {

    //得到一个文件对象f->e:/1.txt

    File f = new File("e:/1.txt");

    FileInputStream fis = null;

    //因为File类没有读写的能力,所以需要使用InputStream

    try {

    fis = new FileInputStream(f);

    //定义一个字节数组 ,相当于一个缓存

    byte[] bytes = new byte[1024];

    int n = 0;  //记录实际读取到的字节数

    //循环读取

    while((n = fis.read(bytes)) != -1) {  //read函数因为已经到达文件末尾而没有更多的数据,则返回-1.

    //把字节转成String

    String s = new String(bytes, 0, n);

    System.out.println(s);

    }

     

    catch (Exception e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    finally {

    //关闭文件流 必须放在这里

    try {

    fis.close();

    catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    }

     

    把内容保存到文件中:

    //演示FileOutputStream流的使用

    package com.test5;

    import java.io.*;

    public class Test {

    public static void main(String[] args) {

    /*BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    String str = null;

    try {

    while((str = br.readLine()) != null) {

    System.out.println(str);

    }

    } catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }*/

    File f = new File("e:/3.txt");

    //字节输出流

    FileOutputStream fos =  null;

     

    try {

    fos = new FileOutputStream(f);

    String s = "小米  ok helloworld\r\n";  //加上\r\n(回车换行),“中国您好”就会在文件中换行输出

    String s1 = "中国您好";

    fos.write(s.getBytes());  //将String类型转成byte数组作为参数

    fos.write(s1.getBytes());

    catch (Exception e) {

    e.printStackTrace();

    finally {

    try {

    fos.close();

    catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    }

    /*用io流复制图片

     * 思路:先把图片读入到内存,然后在写入到某个文件

     * 因为图片是二进制文件,因此只能用字节流完成

     */

     

    package com.test6;

    import java.io.*;

    public class Test {

    public static void main(String[] args) {

    File f1 = new File("E:\\壁纸\\新建文件夹\\tankD.gif");//源文件

    FileInputStream fis = null;

    FileOutputStream fos = null;

    try {

    fis = new FileInputStream(f1);

    fos = new FileOutputStream("e:/meinv.jpg");  //复制到目的地

    byte[] buf = new byte[512];

    int n = 0;//实际读取到的字节数

    //循环读取

    while((n=fis.read(buf)) != -1) {

    //输出到指定文件

    fos.write(buf);

    }

    catch (FileNotFoundException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    catch (Exception e) {

    e.printStackTrace();

    finally {

    try {

    fis.close();

    fos.close();

    catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    }

     

    /*

     * 演示文件字符流的案例(文件的复制)

     * 即文件的读入和写出

     */

    package com.test7;

    import java.io.*;

    public class Test {

    public static void main(String[] args) {

    //文件取出字符流对象(输入流)

    FileReader fr = null;

    //写入到文件(输出流)

    FileWriter fw = null;

    try {

    fr = new FileReader("e:/1.txt");

    fw = new FileWriter("e:/4.txt");

    //读入到内存

    int n = 0; //实际读取到的字符数

    char c[] = new char[1024];

    while((n=fr.read(c))!= -1)//read()方法如果已到达流的末尾,则返回-1

    {

    fw.write(c, 0, n);  //防止输出的文件用记事本打开没有乱码用EditPlus则会出现乱码

    }

    catch (IOException e) {

    e.printStackTrace();

    finally {

    try {

    fr.close();

    fw.close();

    catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    }

    * 我的记事本:界面加功能

     */

    package com.test8;

    import java.awt.*;

    import java.awt.event.*;

    import java.io.*;

     

    import javax.swing.*;

    public class NotePad extends JFrame implements ActionListener{

     

    //定义需要的组件

    JTextArea jta = null;

    //菜单条

    JMenuBar jmb = null;

    //第一个JMenu

    JMenu jm1 = null;

    //定义JMenuItem 

    JMenuItem jmi1 = null;

    JMenuItem jmi2 = null;

    public static void main(String[] args) {

    NotePad np =  new NotePad();

    }

     

    public NotePad() {

    //创建jta

    jta = new JTextArea();

    jmb = new JMenuBar();

    jm1 = new JMenu("文件");

     

    //设置助记符

    jm1.setMnemonic('F');

    jmi1 = new JMenuItem("打开", new ImageIcon("open.gif"));

    //注册监听

    jmi1.addActionListener(this);

    jmi1.setActionCommand("open");

    jmi2 = new JMenuItem("保存");

    //对保存菜单处理

    jmi2.addActionListener(this);

    jmi2.setActionCommand("save");

     

     

    //加入

    this.setJMenuBar(jmb);

    //把jm1放入jmb

    jmb.add(jm1);

    //把item放入Menu

    jm1.add(jmi1);

    jm1.add(jmi2);

    //放入JFrame

    this.add(jta);

    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    this.setSize(400, 300);

    this.setVisible(true);

    }

     

    @Override

    public void actionPerformed(ActionEvent arg0) {

    // TODO Auto-generated method stub

    //判断那个菜单被选中

    if(arg0.getActionCommand().equals("open")){

    //System.out.println("open");

    //推荐JFileChooser

    JFileChooser jfc1 = new JFileChooser();

    //设置名字

    jfc1.setDialogTitle("请选择文件……");

    jfc1.showOpenDialog(null);  //表示打开时使用默认方式打开

    jfc1.setVisible(true);  //显示

     

    //得到用户选择的绝对路径

    String filename = jfc1.getSelectedFile().getAbsolutePath();

    //System.out.println(filename);

    //BufferedReader 处理字符效率比较高

    FileReader fr = null;

    BufferedReader br = null;

    try {

    fr = new FileReader(filename);

    br = new BufferedReader(fr);

     

    //从文件中读取信息并显示到jta

    String s = "";

    String allCon = "";

    while((s = br.readLine()) != null) {

    //显示到记事本中

    allCon += s + "\r\n"; 

    }

     

    //放置到jta即可

    jta.setText(allCon);

    } catch(Exception e) {

    e.printStackTrace();

    } finally {

    try {

    br.close();

    fr.close();

    } catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    } else if (arg0.getActionCommand().equals("save")) {

    //出现保存对话框

    JFileChooser jfc = new JFileChooser();

    jfc.setDialogTitle("另存为……");

    //按默认方式显示

    jfc.showSaveDialog(null);

    jfc.setVisible(true);

     

    //得到用户希望把文件保存到何处,文件的绝对路径

    String file = jfc.getSelectedFile().getAbsolutePath();

    //准备写入到指定文件即可

    FileWriter fw = null;

    BufferedWriter bw = null;

    try {

    fw = new FileWriter(file);

    bw = new BufferedWriter(fw);

    bw.write(this.jta.getText());

     

    } catch (IOException e) {

    e.printStackTrace();

    } finally {

    try {  //注意这里关闭时关闭顺序不能互换,否则内容不能被写出去

    bw.close();

    fw.close();

     

    } catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

     

    }

    }

    界面如下:

    关闭 

     

    注意:关闭io流或数据库连接都应遵循一个原则:  后打开的先关闭;

    集合:ArrayList集合可以实现栈和队列两种功能。当给集合中添加元素时,如果用addlLast()则是队列的形式存放(先进先出),如果用addFirst()则是以栈的形式存放(先进后出)。

     

    Java的Swing编程中,使用JFrame jf = new JFrame();   jf..setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 则在关闭窗口时也保证jvm(java虚拟机同时也退出)。

     

    选择字段类型时如何判断何时使用char或varchar:

    1.varchar是可变长的,可以节省空间,但是查询时效率比较低

    2.Char不可变长,当可以确定字段的长度是应该使用char,因为可以提高查询速度。

     

     

    数据库中表的主键不能重复,主键不能为空,主键可以修改(但不能修改为已经从在的主键。)

    Sql中null不能用=来匹配,而要用is 例如:

     

     

     

    快速自增长插入语句:

    委屈

     

    /*演示使用jdbc-odbc桥连的方式操作数据库  (student)

     * 1.配置数据源

     

    连接sqls2005的插入语句:

    import java.sql.*;

     

    /*演示使用jdbc-odbc桥连的方式操作数据库  (student)

     * 1.配置数据源

     * 2.在程序中去连接数据源

     */

    public class Test {

    public static void main(String[] args) {

    Connection conn = null;

    Statement stmt = null;

    ResultSet rs = null;

    try {

    //1.加载驱动,(作用是把需要的驱动加入内存)

    Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

    //2.得到连接(指定连接到那个数据源,用户名和密码)

    conn = DriverManager.getConnection("jdbc:odbc:mytest","sa","");

    //3.创建statement和PreparedStatement

    //Statement:主要用于发送sql语句到数据库

    stmt = conn.createStatement();

    //4.执行(crud,创建数据库,备份数据库,删除数据……)

    //1.演示添加一条数据到xmk

    /*int i = stmt.executeUpdate("insert into test(sname,sex) values ('ljj','男')");

    if(i == 1) {

    System.out.println("插入ok");

     

    } else {

    System.out.println("失败");

    }*/

     rs = stmt.executeQuery("select * from test");

    while(rs.next()) {

    int i = rs.getInt(1);

    String name = rs.getString(2);

    String sex = rs.getString(3);

    System.out.println(i + " " + name + " " + sex);

    }

     

    catch (ClassNotFoundException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    catch (SQLException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    finally {

    try {

    rs.close();

    stmt.close();

    conn.close();

    catch (Exception e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    }

     

    学习网络最经典的教程:

    追踪数据包发送经过的路由:

     

    本地回绕地址:127.*.*.* 不一定非要是:127.0.0.1

     

    Java中得到整个屏幕的宽度和高度:

    用Swing组件创建的窗口的关闭方法:

    取出登录时的用户名和密码:

    `Model2开发满含楼餐饮系统的模式图:

    学习tcp/ip的必看书籍:(网络黑客的圣经)

     

     

    单例模式的形成过程:

     

     

     

     

     

    在程序中通过程序代码动态的编译类:

     

    UDPSocket编程: (服务器端)

    import java.io.IOException;

    import java.net.DatagramPacket;

    import java.net.DatagramSocket;

    import java.net.InetAddress;

    import java.net.SocketException;

    import java.net.UnknownHostException;

    public class UDPServer {

    public static void main(String[] args) {

    try {

    DatagramSocket ds = new DatagramSocket(6000);

    byte[] buf = new byte[100];

    DatagramPacket dp = new DatagramPacket(buf,100 );

    ds.receive(dp);

    System.out.println(new String(buf, 0, dp.getLength()));

    String str = "Welcome you!";

    DatagramPacket spSend = new DatagramPacket(str.getBytes(), str.length(), dp.getAddress(), dp.getPort());

    ds.send(spSend);

    ds.close();

    catch (SocketException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    (客户端:)

    import java.io.IOException;

    import java.net.DatagramPacket;

    import java.net.DatagramSocket;

    import java.net.InetAddress;

    import java.net.SocketException;

    import java.net.UnknownHostException;

    public class UDPClient {

    public static void main(String[] args) {

    try {

    DatagramSocket ds = new DatagramSocket();

    String str  = "Hello, this is zhangsan";

    DatagramPacket dp = new DatagramPacket(str.getBytes(), str.length(), InetAddress.getByName("localhost"), 6000);

    ds.send(dp);

    byte[] buf = new byte[100];

    DatagramPacket dpRecv = new DatagramPacket(buf, 100);

    ds.receive(dpRecv);

    System.out.println(new String(buf, 0, dpRecv.getLength()));

    ds.close();

    catch (SocketException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    catch (UnknownHostException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    简单的以二进制格式下载的简易下载程序:(孙鑫Java无难事12.rar\孙鑫Java无难事12)

    package com.bjsxt.url;

     

    import java.awt.event.*;

    import java.io.*;

    import java.net.*;

    import javax.swing.*;

     

    public class Download {

    public static void main(String[] args) {

    JFrame jf = new JFrame("下载程序");

    jf.setSize(600, 400);

    jf.setLocation(100, 100);

    JPanel jp = new JPanel();

    JLabel jl = new JLabel("Please input URL:");

    final JTextField tf = new JTextField(30);

    jp.add(jl);

    jp.add(tf);

    jf.getContentPane().add(jp, "North");

    final JTextArea ta = new JTextArea();

    jf.getContentPane().add(ta);

    JButton btn = new JButton("Download");

    btn.addActionListener(new ActionListener() {

    @Override

    public void actionPerformed(ActionEvent arg0) {

    String str = tf.getText();

    try {

    URL url = new URL(str);

    URLConnection urlConn = url.openConnection();

    String line = System.getProperty("line.separator");

    ta.append("Host:" + url.getHost());

    ta.append(line);

    ta.append("Port:" + url.getDefaultPort());

    ta.append(line);

    ta.append(urlConn.getContentType());

    ta.append(line);

    ta.append("ContentLength:" + urlConn.getContentLength());

    InputStream is = urlConn.getInputStream();

    //InputStreamReader isr = new InputStreamReader(is);

    //BufferedReader br = new BufferedReader(isr);

    FileOutputStream fos = new FileOutputStream("1.html");

    //String strLine;

    //while((strLine = br.readLine()) != null) {

    int data;

    while((data = is.read()) != -1) {

    //fos.write(strLine.getBytes());

    //fos.write(line.getBytes());

    fos.write(data);

    }

    //br.close();

    is.close();

    fos.close();

    catch (MalformedURLException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    });

    jf.getContentPane().add(btn, "South");

    jf.setDefaultCloseOperation(jf.EXIT_ON_CLOSE);

    jf.setVisible(true);

    }

    }

     

    多态的三个特性:

    1.有继承

    2.有重写

    3.有父类引用指向子类对象。

    注意:因为继承的父类发生改变时子类一定会发生改变,所以继承的耦合度比较高,为降低耦合度,应谨慎使用继承。

     

    Java的反射机制的应用举例:

    import java.lang.reflect.InvocationTargetException;

    import java.lang.reflect.Method;

    public class TestReflection {

    public static void main(String[] args) {

    String str = "T";

    try {

    Class c = Class.forName(str);

    Object o = c.newInstance();  //创建一个类的对象

    //拿到该类的所有方法名并放入数组中

    Method[] methods = c.getMethods();

     

    for(Method m : methods) {

    //通过反射机制调用mm方法

    if(m.getName().equals("mm")) {

    m.invoke(o);

    }

    //可变参数的应用

    if(m.getName().equals("m1")) {

    m.invoke(o, 1, 2);

    //拿到m1方法的参数类型

    for(Class paramType : m.getParameterTypes()) {

    System.out.println(paramType.getName());

    }

    }

    //System.out.println(m.getName());

    //拿到方法的返回值的类型

    if(m.getName().equals("getS")) {

    Class returnType = m.getReturnType();

    System.out.println(returnType.getName());

    }

    }

    catch (ClassNotFoundException e) {

    e.printStackTrace();

    catch (InstantiationException e) {

    e.printStackTrace();

    catch (IllegalAccessException e) {

    e.printStackTrace();

    catch (IllegalArgumentException e) {

    e.printStackTrace();

    catch (InvocationTargetException e) {

    e.printStackTrace();

    }

    }

    }

    class T {

    static {

    System.out.println("T loaded!");

    }

    public T() {

    System.out.println("T constructed!");

    }

    int i;

    String s;

    public void m1(int i, int j) {

    this.i = i + j;

    System.out.println(this.i);

    }

    public void mm() {

    System.out.println("mm invoked");

    }

    public String getS() {

    return s;

    }

    }

     

     

     

     

     

     

    Struts2中最常用的几个标签:

    注意如下sql语句中的where、group by、 having、 order by的顺序;

         

     

    设计单例的方法:

     

     

     

     

    当以这样的方式向数据库中插入时间时,可以保存年、月、日、时、分、秒:

     

    数据库连接池的配置

    可以通过tomcat的管理页面配置各种数据库的连接池(可以参考王勇的drp中oracle的连接池的配置):通过tomcat管理页面配置的连接池是放在tomcat--》conf下的——》server.xml

    文件中:

    <Resource 

    name="jdbc/ljj"

    type="javax.sql.DataSource"

    password="drp"

    driverClassName="oracle.jdbc.driver.OracleDriver"

    maxIdle="2"

    maxWait="5000"

    username="drp"

    url="jdbc:oracle:thin:@localhost:1521:orcl"

    maxActive="4"

    />

    可以将上面的这些内容剪贴到tomcat--》conf--》context中如下;

    <!-- The contents of this file will be loaded for each web application -->

    <Context>

     

        <!-- Default set of monitored resources -->

        <WatchedResource>WEB-INF/web.xml</WatchedResource>

     

        <!-- Uncomment this to disable session persistence across Tomcat restarts -->

        <!--

        <Manager pathname="" />

        -->

     

    <Resource 

    name="jdbc/ljj"

    type="javax.sql.DataSource"

    password="drp"

    driverClassName="oracle.jdbc.driver.OracleDriver"

    maxIdle="2"

    maxWait="5000"

    username="drp"

    url="jdbc:oracle:thin:@localhost:1521:orcl"

    maxActive="4"

    />

    </Context>

    然后如果context.xml文件是放在tomcat原来的目录下不改变的话该连接池对所有配置到tomcat上的项目都起作用,也可以将context.xml文件剪贴到MyEclipse中的某一个项目WeebRoot--》Web-INF下,这样就可以对该项目起作用,而对其他项目不起作用。

    然后在jsp页面中具体使用连接池的具体方法是(如果取得连接Connection后,与使用jdbc没有什么区别):

    <%@ page language="java" import="java.util.*" pageEncoding="GB18030"%>

    <%

    String path = request.getContextPath();

    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";

    %>

    <%@ page import="java.sql.*" %>

    <%@ page import="javax.sql.*" %>

    <%@ page import="javax.naming.*" %>

    <%

    Connection conn = null;

    PreparedStatement pstmt = null;

    ResultSet rs = null;

     try {

    Context ctx = new InitialContext();

    //通过JNDI查找DataSource

    DataSource ds = (DataSource)ctx.lookup("java:comp/env/jdbc/ljj");

    conn = ds.getConnection();

    pstmt = conn.prepareStatement("select * from m_user");

    rs = pstmt.executeQuery();

    out.println("输出数据如下");

    while(rs.next()) {

    out.println("id==" + rs.getInt("userid") + ", " + rs.getString("username" ));

     

    }

     } catch (Exception e) {

     e.printStackTrace();

     } finally {

     try {

     if(rs != null) rs.close();

     if(pstmt != null) pstmt.close();

    //注意:该链接一定要归还给连接池,否则会出问题:

     if(conn != null) conn.close(); 

     

     } catch (Exception e) {

     e.printStackTrace();

     }

     

     

     }

     

    %>

    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

    <html>

      <head>

        <base href="<%=basePath%>">

        

        <title>My JSP 'user_test.jsp' starting page</title>

        

    <meta http-equiv="pragma" content="no-cache">

    <meta http-equiv="cache-control" content="no-cache">

    <meta http-equiv="expires" content="0">    

    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">

    <meta http-equiv="description" content="This is my page">

    <!--

    <link rel="stylesheet" type="text/csshref="styles.css">

    -->

     

      </head>

      

      <body>

       user_Test.jsp <br>

      </body>

    </html>

     

     }

     

     

    链式编程的编程技巧:

    public class FilterChain {

    List<Filter> FilterList = new ArrayList<Filter>();

     

    //链式编程的技巧

    public FilterChain addFilter(Filter f){

    this.FilterList.add(f);

    return this;

    }

    }

    在主方法中:

    public class Main {

    public static void main(String[] args) {

    FilterChain fc = new FilterChain();

    //开始链式编程

    fc.addFilter(new HTMLFilter())

    .addFilter(new SesitiveFilter())

    .addFilter(new FaceFilter());

    }

    }

    注意:判断内存中两份字节码是否相等应该用“==”来比较。(因为同一个类的字节码在内存中尽有一个类)

    对于数据库连接对象、输入输出流对象等物理资源,不会被垃圾回收器自动回收的,必须要手动释放,方法是在try-catch-finally的finally块中编写释放资源的代码。

    默认构造方法都是public的?

    需要开发人员注意的是,默认的构造方法(是指在java编译器中自动生成的构造方法)未必都是public的,并且默认的构造方法是一定有super()方法的。在现实中,默认构造方法的修饰符是与所在类的修饰符一致的,也就是说如果类是public的,默认构造方法的修饰符就是public的;如果类无修饰符,默认构造方法也将没有修饰符。例如下面的代码:

    public class Test{

        //默认的构造方法

        public Test(){

            super();

        }

    }

    如果类无修饰符:

    class Test{

        //默认的构造方法

        Test(){

            super();

        }

    }

    配置用EditPlus作为java编译器:

    在定义接口时, 只有在接口中抛异常,实现接口的子类中才能抛比父类小的异常,如果父类不抛异常,则子类不能抛异常,RuntimeException异常除外。

    每文一语:己所不欲,勿施于人

    请关注我微信公众号:

     

     

    展开全文
  • Java读取和写入图片

    万次阅读 2018-06-05 21:14:38
    File originalFile = new File("...//指定要读取的图片 try { File result = new File("D:\\test0\\dabai.jpg");//要写入的图片 if (result.exists()) {//校验该文件是否已存在 ...
            File originalFile = new File("D:\\test\\dabai.jpg");//指定要读取的图片
            try {
                File result = new File("D:\\test0\\dabai.jpg");//要写入的图片
                if (result.exists()) {//校验该文件是否已存在
                    result.delete();//删除对应的文件,从磁盘中删除
                    result = new File("D:\\test0\\dabai.jpg");//只是创建了一个File对象,并没有在磁盘下创建文件
                }
                if (!result.exists()) {//如果文件不存在
                    result.createNewFile();//会在磁盘下创建文件,但此时大小为0K
                }
                FileInputStream in = new FileInputStream(originalFile);
                FileOutputStream out = new FileOutputStream(result);// 指定要写入的图片
                int n = 0;// 每次读取的字节长度
                byte[] bb = new byte[1024];// 存储每次读取的内容
                while ((n = in.read(bb)) != -1) {
                    out.write(bb, 0, n);// 将读取的内容,写入到输出流当中
                }
             
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally{
                //执行完以上后,磁盘下的该文件才完整,大小是实际大小
                out.close();// 关闭输入输出流
                in.close();
            }

    两份图片大小与尺寸相同

     

    展开全文
  • Java图片上传

    万次阅读 2015-05-15 17:46:40
    图片上传,其实,也可以按照之前文章——文件上传的方式实现,因为图片...首先,文件,需要知道文件的路径,比如放在C盘下面的某个文件。然后把这个图片通过画笔方式给画出来。放到指定服务器路径下。不需要第三方插

                 图片上传,其实,也可以按照之前文章——文件上传的方式实现,因为图片也是文件。只要是文件,都可以用流来接收,然后把流给写出到指定的物理空间下,形成我们需要的物理文件。

                 今天,我们就不用上传文件的方式,这种方式和我之前的一篇制作二维码的文章类似。首先,读文件,需要知道文件的路径,比如放在C盘下面的某个文件。然后把这个图片通过画笔方式给画出来。放到指定服务器路径下。不需要第三方插件,sun公司提供的image工具类就可以实现。

    下面我们把桌面上的blue.png图片上传到服务器上。

    public static String imgUpload(HttpServletRequest request,
                                       HttpServletResponse response)
            throws Exception
        {
            String resultPath = "";
            String filePath = "C:/Users/Administrator/Desktop/blue.png";
            String savePath = request.getRealPath("/save/");
            File uploadDir = new File(savePath);
            File file = new File(filePath);
    
            if ( !file.isFile())
            {
                return "不是文件类型";
            }
            if ( !uploadDir.exists())
            {
                uploadDir.mkdirs();
            }
            BufferedImage img = ImageIO.read(file);
            if (img != null)
            {
                BufferedImage tag = new BufferedImage(img.getWidth(),
                    img.getHeight(), BufferedImage.TYPE_INT_RGB);
                tag.getGraphics().drawImage(img, 0, 0, img.getWidth(),
                    img.getHeight(), null);
    
                int lastLength = filePath.lastIndexOf(".");
                Date date = new Date(System.currentTimeMillis());
                String strDate = new SimpleDateFormat("yyyyMMddhhmmss").format(date);
                int random = (int) (Math.random() * 99);
                String imageName = strDate + random; //以系统时间来随机的创建图片文件名
                String fileType = filePath.substring(lastLength); //获取上传图片的类型
                resultPath = savePath + imageName + fileType;
                System.out.println(resultPath);
    
                FileOutputStream out = new FileOutputStream(resultPath);
                JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
                JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(tag);
                param.setQuality(0.95f, true); //95%图像       
                param.setDensityUnit(1); //像素尺寸单位.像素/英寸     
                param.setXDensity(300); //水平分辨率       
                param.setYDensity(300); //垂直分辨率 
                encoder.setJPEGEncodeParam(param);
                encoder.encode(tag);
                tag.flush();
                out.flush();
                out.close();
            return resultPath;
        }


    这种方式上传图片,好处就在于,可以控制图片的大小尺寸,可以按照自己的需要进行裁剪压缩图片。








    展开全文
  • #java读书笔记#IO流2

    千次阅读 2016-05-29 23:39:42
    (4)需求4:拷贝字节文件,如图片或者MP3或者电影 第一种拷贝:不带缓冲区(慢,还是效率问题) FileInputStream fis = new FileInputStream("g:\\1.mp3"); FileOutputStream fos = new FileOutputStream("g:\\...
  • 在很多的网站都可以实现上传头像,可以选择自己喜欢的图片做头像,从本地上传,下次登录时可以直接显示出已经上传的头像,那么这个是如何实现的呢? 下面说一下我的实现过程(只是个人实现思路,实际网站怎么实现的...
  • /** * 将图片转换为base64格式 ... * @param sizeLimit:原图大小上限,当图片原图大小超过该值时先将图片大小 设置为该值以下再转换成base64格式,单位kb * @return */ public static String convertImageToB...
  • java Image大小处理

    千次阅读 2016-03-15 21:23:24
    //获取硬盘上的图片   Image inputImage = ImageIO.read(new File("c:/touxiang.jpg")); //创建一个BufferedImage  BufferedImage image = new BufferedImage(300,400,BufferedImage.TYPE_3BYTE_BGR); //...
  • java图片内存溢出问题解决办法

    千次阅读 2007-11-25 22:43:00
    最近一直在忙Rcp,swt、jface的图片处理问题。做了个图片查看编辑软件,在开发过程中发现只要是分辨率过...java读图片大小不是图片的真实大小,而是根据图片的像素来计算的,一个4M左右的图片被读入后实际大约50M左右
  • 获取base64编码格式的图片大小

    万次阅读 2020-06-07 14:34:19
    //imageBase就是要传来的图片数据 因为我传来的照片头部已经去掉了,所以这里就不需要再做处理,只做“=”号的处理就可以了 public int obtainImageSize(String imageBase){ String str = imageBase; str = str....
  • 本文介绍了Java IO流的基本概念,使用方法,以及使用的注意事项等。帮助你更好地理解和使用Java的IO流。 具体代码在我的GitHub中可以找到 https://github.com/h2pl/MyTech 喜欢的话麻烦点一下星哈谢谢。 文章...
  • 使用JAVA爬取网页图片

    千次阅读 2017-12-10 15:49:43
    经过之前的HttpURLConnection还有各种流的结束,已经可以开始理解怎么下载网页上的一张图片了。 对各种流不理解的话,可以翻翻前面的随笔,讲得都比较详细。在此就不细讲了。 主要流程: 1、...
  • package com.rzxt.fyx.common.util; import java.awt.AlphaComposite; import java.awt.Color; import java.awt.Font; import java.awt.Graphics2D; import java.awt.Image; import java.awt.RenderingHin
  • java图片按照原尺寸比例存入word中

    千次阅读 2020-02-17 12:34:31
    在使用poi往word里面插入图片时可以使用 XWPFParagraph.insertNewRun(i).addPicture(InputStream pictureData, int pictureType, String filename, int width, int height)方法 但是为了使得插入word中的图片按照...
  • Java(2)-Java IO输入输出流

    万次阅读 多人点赞 2012-04-01 11:28:55
    Java中I/O操作主要是指使用Java进行输入,输出操作.Java所有的I/O机制都是基于数据流进行输入输出,这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的...
  • 1,读取片的地址,获取图片的Image File file = new File("./src/reasources/logo_s.jpg");// 读入文件 Image image = ImageIO.read(file); 2,进行压缩图片 /** * 压缩或者增大图片 * @param ...
  • java生成图片验证码的源码

    千次阅读 2014-10-28 16:42:16
    package com.hzjw.common; import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.image.BufferedImage; import java.io.IOException; import java.io.OutputStream; import j
  • Java面试题大全(2020版)

    万次阅读 多人点赞 2019-11-26 11:59:06
    发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~ 本套Java面试题大全,全的不能再全,哈哈~ 一、Java 基础 1. JDK 和 JRE 有什么区别? JDK:Java ...
  • 使用java的IO复制图片文件

    千次阅读 2020-09-09 19:53:12
    使用java的IO复制图片文件 详细步骤都在代码的注释中! java代码如下: package com.lbl.io; import org.junit.Test; import java.io.*; public class IOTest { @Test public void IOTest() throws IOException...
  • 给按钮添加背景图片,如何调整背景图片大小,纠结了很久,终于在网上找到了一个解决方法,拿出来和大家分享一下: public void setIcon(String file, JButton iconButton) {   ImageIcon icon = new...
  • package test; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException;... * 通过像素的缩放技术,改变图片大小 * --等距采样法 */ public class ImageChange {
  • Java操作mysql存储图片

    千次阅读 2011-04-26 11:23:00
    Java操作mysql存储图片转载 转:[url=http://www.cnblogs.com/5211314WL/archive/2011/03/24/JavaAndMysqlIn.html]huajian168 [/url] [align=center][size=4]Java操作mysql存储图片转载[/size][/align] ...
  • java上传图片或者文件到nginx服务器

    万次阅读 2018-08-21 15:01:50
    其实上传文件跟这个也是一样的,当然这里面少了一些判断,比如限制文件的大小等. 当你完成之后访问你上传的图片或者文件可能会出现下面的情况 标题这个因为你创建的目录和用户组是root,Nginx进程是Nginx用户启动的,...
  • 设置文字的位置、大小、样式、类型、透明度、颜色等 给图片添单个文字水印 /* * 给图片添加单个文字水印类 * */ public class TextWatermarking { //定义图片水印字体类型 public static final String FONT_...
  • 用户分类浏览系统中的图片缩略图用户查看单张图片的详细信息,图片下载用户查看一个分类内的所有图片缩略图用户使用关键字进行模糊搜索管理员登录管理员拥有普通用户的所有功能,同时能够实现图片的删除 使用的主要...
  • 牛逼!Java 从入门到精通,超全汇总版

    万次阅读 多人点赞 2021-05-06 19:40:33
    文章目录Java 基础Head First JavaJava 核心技术卷一Java 编程思想设计模式Head First 设计模式图解设计模式设计模式重学 Java 设计模式Java 进阶Java 并发编程实战Java 并发编程艺术Java 并发编程之美图解Java多...
  • 10万+IT人都在关注的图片批量压缩上传方案(完整案例+代码) 背景需求:为了客户端访问图片资源时,加载图片...需要写一个Java小工具把本地磁盘中的图片资源一键上传至分布式FastDFS文件服务器,并把图片信息存入本地...
  • java 读取图片的缩略图和dpi

    千次阅读 2011-08-14 15:54:23
    最近帮朋友做了个管理图片的小软件,要求实现的功能就是对大量的jpg图片生成缩略图显示,自动计算图片的平方数以便计费。最初感觉从图片读取信息应该是很简单的问题,哪知道还是花了好几天才搞定,杯具啊! 刚开始我...
  • 自己整理的 Effective Java 第二版的知识点,做成了思维导图,Xmind编辑的。
  • java图片处理---Javax.imageIO包的用法

    万次阅读 2014-05-27 20:56:33
    Java中进行图像I/O(即读图片和写图片,不涉及到复杂图像处理)有三个方法: 1. Java Image I/O API,支持常见图片,从Java 2 version 1.4.0开始就内置了。 主页:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 49,275
精华内容 19,710
关键字:

java读图片的大小

java 订阅