起步

导出时报错:

导出war包时报 SECURITY ALERT: INTEGERITY CHECK ERROR

数据采集

Android端

重写onTouchEvent,收集event数据,以一定的编码传输

public boolean onTouchEvent(MotionEvent event){
    String rec="";
    int pointerCount = event.getPointerCount();
    if (pointerCount > MAX_TOUCHPOINTS) {
        pointerCount = MAX_TOUCHPOINTS;
    }
    int opt=event.getAction();
    boolean isFirst=true;
    if(opt==2){
        for (int i = 0; i < pointerCount; i++) {
            int id = event.getPointerId(i);
            int x = (int) event.getX(i);
            int y = (int) event.getY(i);
            if(isFirst){isFirst=false;}
            else rec+=";";
            rec+=id+",2,"+x+","+y;
        }
    }else if(opt==0||(opt-5)%256==0){
        //为了简化，我们假设这过程不会进行MOVE
        int ind=(event.getAction()-5)/256;
        for (int i = 0; i < pointerCount; i++) {
            if(i==ind){
                int id = event.getPointerId(i);
                int x = (int) event.getX(i);
                int y = (int) event.getY(i);
                if(isFirst){isFirst=false;}
                else rec+=";";
                rec+=id+",0,"+x+","+y;
                break;
            }
        }
    }else if(opt==1||(opt-6)%256==0){
        int ind=(event.getAction()-6)/256;
        for (int i = 0; i < pointerCount; i++) {
            if(i==ind){
                int id = event.getPointerId(i);
                if(isFirst){isFirst=false;}
                else rec+=";";
                rec+=id+",1";
                break;
            }
        }
    }
    return true;
}

1.synchronized 基础

1.1synchronized 实例方法与静态方法的区别

1.2重入不死锁

public class Base {
    public  synchronized void say (){
        System.out.println("Base");
    }

}

public class Child extends Base{

    @Override
    public synchronized void say() {
        // TODO Auto-generated method stub
        System.out.println("Child");
        super.say();//正常super.say方法获取不到对象锁(重入)，不过由于处于同一个锁，系统解决该问题了。
    }
}

    public static void main(String[] args) {
        // TODO Auto-generated method stub
//      testClassAndObject();
        Child c=new Child();
        c.say();
    }

源码未看完，先占坑

每个Thread维护一个ThreadLocalMap

获取ThreadLocalMap

/**
     * Get the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param  t the current thread
     * @return the map
     */    
ThreadLocalMap getMap(Thread t) {
            return t.threadLocals;
        }

Java IO

java.io.File类用于表示文件（目录）

File类只用于表示文件（目录）的信息（名称、大小等），不能用于文件内容的访问

File file = new File("F:\\临时文档\\958032738");//填入相对或绝对地址
//判断文件(夹)是否存在
if(!file.exists())
    file.mkdir(); //创建文件夹
else
    file.delete();//删除文件夹
//是否是一个目录  如果是目录返回true,如果不是目录or目录不存在返回的是false
System.out.println(file.isDirectory());
//是否是一个文件 如果是文件返回true,如果不是文件or文件不存在返回的是false
System.out.println(file.isFile());
//new file 的构造方式
File file2 = new File("e:\\javaio\\日记1.txt");
File file3 = new File("e:\\javaio","日记1.txt");
if(!file2.exists())
    try {
        file2.createNewFile();//创建文件
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
else 
    file2.delete();//删除文件
         //常用的File对象的API
System.out.println(file);//file.toString()的内容 F:\临时文档\958032738
System.out.println(file.getAbsolutePath());//绝对地址 F:\临时文档\958032738
System.out.println(file.getName());//文件（夹）名   958032738
System.out.println(file.getParent());//父文件夹 toString F:\临时文档
System.out.println(file.getParentFile().getAbsolutePath());//F:\临时文档
//列出该目录下的所有文件(夹) 返回的是文件(夹)的名字数组(非路径)
String filenames[] = file.list();
for(String filename:filenames)
    System.out.println(filename);

目录文件遍历

第一章 简介

内存分配3种方式

静态分配：

局限 每个数据结构的大小必须在编译时可知 过程不能递归，因为对于过程的每个活动(过程体的一次执行)，局部名字在内存中共享相同位置(这时一般用的是栈分配) 无法动态创建数据结构 优点 效率高，不需要在程序执行时创建和销毁栈帧 编译器知道所有数据的内存位置，可直接访问存储位置 内存需求预知，不会发生OOM

栈分配：

特点 可递归调用 栈分配的局部值，无法从过程体的一次执行保存到过程体的下一次执行(这时一般用的是静态分配) 被调用者的生命周期<=它的调用者 只有大小能在编译时确定的对象，才能作为过程的结果返回

堆分配

动态大小的对象可作为过程结果返回 数据结构大小不固定 允许把一个过程作为另一个过程的结果返回