文档章节

java琐碎知识

Scofieldxs
 Scofieldxs
发布于 2015/10/09 20:49
字数 1983
阅读 196
收藏 4

###1.java二维数组

java实际上并没有二维数组的概念,二维数组第一个量实际上每一个元素都是另一个int数组的引用

实际的解释

因此访问顺序很重要,若是按行访问比较快,按列访问很慢

###2.java国际化(I18n) 主要是两个类:

  • java.util.Locale:提供静态常量

      Locale locale = Locale.CHINA;
      System.out.println(locale.getCountry());
      System.out.println(locale.getDisplayLanguage());
      //out:   CN    中文
    
  • ResourceBundle

###3.异常

父类:java.lang.Throwable

分为两大类:

  • Error:无法处理的异常,jvm会停止工作
  • Exception
    • checked Exception:强制程序员必须进行捕获
      • IOExeption
      • SQLException
    • unchecked Exception:=RuntimeException,不要求必须进行捕获
      • NullPointerException
      • IndexOutOfBoundsException

继承图:

  • throws:出现在方法声明中,表示可能会抛出的异常
  • throw:出现在方法体中,抛出异常

异常的最佳实践

  • 对可恢复的错误使用受检查异常,对变成错误使用非受检查异常
  • finally中释放资源
  • 受检查异常转为运行时异常:DataAccessException

###4.编码格式 ASCII unicode utf-8关系

  • 最早出现的是ASCII码,一个字节,只支持大小写字母和常用字符

  • 为了支持各国文字出现了unicode,两个字节表示。

  • ASCII转unicode前面补8位0即可

  • 为了节省存储空间,出现了utf-8.变长编码,常用英文一个字节,汉字3个字节。

  • 文本编辑时使用unicode,硬盘存储时使用utf-8

  • 浏览网页时把动态unicode转成utf-8显示

###5.string string存储在字符串常量池中,数组形式存储

向substring,split这样的方法,还是指向原字符数组,

如果substring拿了一小部分长时间保存的话,原string是无法GC的,因此最好new String()一个

###6.浅拷贝vs深拷贝

  • 等号赋值只是多了一个引用,指向同一块地址:

      Employee one = new Employee(100, new Date());
      Employee two = one;
      System.out.println(two.equals(one));//true
    
  • Object.clone()方法只是进行浅拷贝,对象中的reference拷贝的还只是引用,因此需要重写clone进行深拷贝

      public class Employee implements Cloneable {
    
          public Object clone() throws CloneNotSupportedException {
              Employee cloned = (Employee) super.clone();
              cloned.date = (Date) date.clone();
              return cloned;
          }
      }
    

必须实现Cloneable接口才行,否则调用clone()时会报 CloneNotSupportedException

  • clone时这样写:

    Employee two = (Employee) one.clone();

###7.native method 表示该方法是用其他语言实现的

常用于与操作系统交互

###8.= 和+= byte a = 127; byte b = 127; b += a;//b转换为int型 b = b + a;//报错:b为byte,b+a为int,无法赋值

###9.equals() and hashcode() 判断两个对象是否相等的规则:

  1. hashcode是否相等
  2. 不相等->对象不相等
  3. 相等->equals判断
  4. equals相等->相等
  5. equals不相等->不相等

原因:hashcode快,先用hashcode判断

equals相等---->hashcode相等 equals不同---->hashcode不一定(可能有哈希冲突)

###10.反射 动态语言:程序运行时能够改变其结构:比如新的函数被引进,旧的函数被删除

####定义:

  • 可以在运行时使用编译期间未知的类,只需要知道它的类名
  • 对于一个已经加载的类,能够知道和调用这个类的所有属性和方法

####通过反射创建对象,调用对象方法,访问成员变量:

1.class对象的newInstance()方法(要求有默认构造器)

2.获取指定的Constructor对象,再newInstance()(可以指定构造器)

目标类Myclass:

	public class Myclass {

	    private int key;

	    public int getKey() {
	        return key;
	    }

	    public void setKey(int key) {
	        this.key = key;
	    }

	}

反射

	public static void main(String[] args) {
        try {
            Class clazz=Class.forName("Myclass");
            //init
            Object object = clazz.newInstance();
            //Myclass myclass=(Myclass)clazz.newInstance();

            //setMethod
            Method setMethod=clazz.getMethod("setKey", int.class);
            setMethod.invoke(object, new Integer(10));

            //getMethod
            Method getMethod=clazz.getMethod("getKey");
            Object result=getMethod.invoke(object);

            System.out.println(result);

            //field
            Myclass myclass=(Myclass)object;
            Field field=Myclass.class.getDeclaredField("key");
            field.setAccessible(true);
            field.setInt(myclass, 20);
            int key=field.getInt(myclass);
            System.out.println(key);

        }catch (Exception e){

        }

    }

####spring中的应用 spring通过反射机制来串讲对象,类似于工厂模式

###11.cglib

代码生成类库,在运行时动态生成某个类的子类

####核心类

  • Enhancer:主要的增强类
  • MethodInterceptor:方法拦截器
  • MethodProxy:代理类

####使用:

  1. 目标类Person:

     public class Person {
    
         public void sayHi(){
             System.out.println("hi");
         }
     }
    
  2. cglib:

     public static void main(String[] args) {
         final Person person=new Person();
    
         Enhancer enhancer=new Enhancer();
         enhancer.setSuperclass(Person.class);
    
         enhancer.setCallback(new MethodInterceptor() {
             public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                 System.out.println("before");
                 Object obj = method.invoke(person);
    
                 System.out.println("after");
    
                 return obj;
    
             }
         });
    
         Person p=(Person) enhancer.create();
    
         p.sayHi();
     }
    

###12.设计模式原则

  • 多用组合,少用继承

  • 对扩展开放,对修改关闭

  • 装饰者模式

###13.xml解析方式

####1.DOM

将xml整体当做一颗树处理;需要全部加载进内存,占用内存;适合小文件

####2.SAX

采用流解析的技术,解决占用资源大的问题;解析过程复杂;适合大文件

###14.IO 在java.io包下

主要包括四部分:

  • 字节操作:InputStream,OutputStream
  • 字符操作:Writer,Reader
  • 磁盘操作:FIle
  • 网络操作:Socket

标准访问文件方式:

写入:用户程序调用write()接口将数据从用户地址空间复制到内核地址空间的缓存中,何时写到磁盘中由操作系统决定。

###15.序列化

指的是将一个对象转化成一串二进制表示的字节数组

必须继承java.io.Serializable接口

基本操作:

	File file=new File("person.out");

    ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream(file));
    Person person=new Person("alis",11);
    out.writeObject(person);
    out.close();

    ObjectInputStream in=new ObjectInputStream(new FileInputStream(file));
    Object obj=in.readObject();
    Person newPerson=(Person)obj;
    System.out.println(newPerson);

静态变量无法序列化

序列化中的数据可以加密

###16.NIO

表示块IO,比原来的流IO效率高。

将最耗时的IO操作(填充和提取缓冲块)转移回操作系统,因此更快

####通道(Channel)和缓冲(Buffer)

对IO包中流的模拟,所有数据必须通过channel对象

通过通道的数据必须先放到Buffer

缓冲区提供了对数据的结构化访问

####读文件

三个步骤:

  • 从FileInputStream获取Channel
  • 创建Buffer
  • 将数据从Channel读到buffer

示例:

	public static void main(String[] args) throws IOException {

        FileInputStream in = new FileInputStream("read.txt");

        FileChannel channel = in.getChannel();

        ByteBuffer buffer = ByteBuffer.allocate(2);

        channel.read(buffer);

        System.out.println(Arrays.toString(buffer.array()));
    }

###17.final

####修饰类 这个类不能被继承

####修饰方法 防止该方法在子类中被覆盖

####修饰变量

  • 基本类型变量:初始化后不能改变
  • 引用类型变量:初始化后不能指向另一个对象

如果在编译期就能确切知道final变量的值,会被当做常量使用:

	final String b="hello";
	String c=b+2;
	String a="hello2"
	System.out.println((a==c));
	//true

###18.hashMap

####两个控制量

  • capacity:指bucket的大小
  • load factor:超载因子,指能放多少的比例

当entries中的数量多于capacity*loadfactor时,capacity扩充为原来2倍

####put()实现

  1. 对key的hashcode()做hash,然后计算index
  2. 如果没有碰撞,放到bucket里
  3. 如果有碰撞,以链表形式连在后面
  4. 如果链表过长,替换成红黑树
  5. 如果节点存在,替换old value
  6. 如果bucket超过限定,容量扩充

####get()实现

  1. 计算key的hashcode()的hash,获取index
  2. 如果第一个节点,直接命中
  3. 如果有冲突,通过key.equals(k)来查找

####hash计算下标index 算法:高16bit不变,低16bit和高16bit做异或

###19.代理proxy

java动态代理机制主类:java.lang.Proxy

代理对象和被代理对象必须实现同一个接口

重要类:

  • InvocationHandler:所有对动态代理对象的方法调用都会转到InvocationHandler接口的实现上

实现

  1. 定义一个目标接口:

     public interface TargetInterface {
    
         int getRandom(int key);
     }
    
  2. 定义接口的实现类

     public class Target implements  TargetInterface {
    
         public int getRandom(int key) {
             return new Random().nextInt(key);
         }
     }
    
  3. 定义一个InvocationHandler,代理的处理就放在这

     public class MyInvocationHandler implements InvocationHandler {
    
         private Object target;
    
         public MyInvocationHandler(Object object){
             this.target=object;
         }
    
         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
             System.out.println("proxy:"+proxy.getClass());
    
             System.out.println("method name:"+method.getName());
    
             System.out.println("args:"+Arrays.toString(args));
    
             return  method.invoke(target,args);
    
         }
     }
    
  4. 测试类:

     public static void main(String[] args) {
         InvocationHandler handler = new MyInvocationHandler(new Target());
    
         TargetInterface target = (TargetInterface) Proxy.newProxyInstance(TargetInterface.class.getClassLoader(),
                 new Class[]{TargetInterface.class}, handler);
    
         int result=target.getRandom(5);
         System.out.println("result:"+result);
    
     }
    

输出:

	proxy:class com.sun.proxy.$Proxy0
	method name:getRandom
	args:[5]
	result:3

应用

  1. spring 数据库事务管理

  2. Mock对象

  3. AOP拦截器

© 著作权归作者所有

共有 人打赏支持
上一篇: spring
下一篇: java操作
Scofieldxs
粉丝 3
博文 24
码字总数 26524
作品 0
海淀
私信 提问
菜鸟网络java岗面经 已拿offer

牛客网上看了很多面经现在回馈一下牛友。 我是一个双非二本java。首先要谢谢我的一个李姓同学。他先去蚂蚁金服。这才告诉我们,双非二本只要技术好大公司也是不会拒绝你的。 还有就是牛客网上...

牛客网
05/10
0
0
Java培训实战教程之Java基础知识精华部分(一)(二)(三)

Java培训实战教程之Java基础知识精华部分(一)_java概述 =============================================================================Java培训实战教程之Java基础知识精华部分(一)_java概...

黑泽明军
04/13
0
0
Java程序员必读书单,家族又添新成员

点击关注异步图书,置顶公众号 每天与你分享IT好书 技术干货 职场知识 参与文末话题讨论,每日赠送异步图书。 ——异步小编 有些革命出其不意地吸引了全世界的眼球。Twitter、Linux操作系统和...

异步社区
05/09
0
0
对JVM还一知半解?这篇文章让你彻底搞定JVM

对于Java开发者来说,想把自身能力提升到更高层次,某些JVM相关知识应该是优先级很高的。比如说GC策略,JVM调优。 就我在工作中遇到的情况来看:接触了几年Java,现在做Java Web的开发,实际...

全部原谅
10/17
0
0
java 7 入门书籍

一、Java从入门到精通 《Java从入门到精通(第3版)》从初学者角度出发,通过通俗易懂的语言、丰富多彩的实例,详细介绍了使用Java语言进行程序开发需要掌握的知识。 《Java从入门到精通(第3版...

modernizr
2014/05/15
6.9K
9

没有更多内容

加载失败,请刷新页面

加载更多

Flink-数据流编程模型

1、抽象等级 Flink提供了不同级别的抽象来开发流/批处理应用程序。 1) 低层级的抽象 最低层次的抽象仅仅提供有状态流。它通过Process函数嵌入到DataStream API中。它允许用户自由地处理来自一...

liwei2000
20分钟前
1
0
Java开发Swing实战JFrame和JTabbedPane容器的用法详细解析

概述: 项目是一个桌面程序,涉及标签和按钮组件、布局管理器组件、面板组件、列表框和下拉框组件等组件,以及Swing事件处理机制。 下面先从最基础的界面开始。 /** * @author: lishuai * @...

金铭鼎IT教育
26分钟前
7
0
flask 之旅

环境 为了正确地跑起来,你的应用需要依赖许多不同的软件。 就算是再怎么否认这一点的人,也无法否认至少需要依赖Flask本身。 你的应用的运行环境,在当你想要让它跑起来时,是至关重要的。 ...

hblt-j
26分钟前
5
0
easyui的上传文件

记录一下自己亲手操刀easyui的心得:不用不知道,一用就问题多,网上查资料,有用的真的太少了 ——————————————————正文 FileBox,还是不错的讲真,至少我去自己写就gaga了...

anlve
27分钟前
4
0
如何做好SQLite 使用质量检测,让事故消灭在摇篮里

本文由云+社区发表 SQLite 在移动端开发中广泛使用,其使用质量直接影响到产品的体验。 常见的 SQLite 质量监控一般都是依赖上线后反馈的机制,比如耗时监控或者用户反馈。这种方式问题是: ...

腾讯云加社区
29分钟前
5
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部