Java的集合类主要是由两个接口派生出来的：Collection 和Map

• Collection
  • Set 无序集合 不可重复
    • EnumSet
    • SortedSet
      TreeSet
    • HashSet
      LinkedHashSet
  • Queue 队列
    • Deque
      ArrayDeque
      LinkedList
    • PriorityQueue
  • List 有序集合 元素可以重复
    • ArrayList
    • LinkedList
    • Vector
      stack
• Map
  • EnumMap
  • IdentityHashMap
  • HashMap(线程不安全，key value 可以为null)
    • LinkedHashMap
  • Hashtable (线程安全key value 不能为null )
    • Properties
  • SortedMap
    • TreeMap
  • WeekHashMap
• Iterator 用来集合遍历

  各个集合的特点

  Set集合

  HashSet 类

  特点：

1. 不能保证元素的排列顺序，顺序有可能发生变换
2. 不是同步的，如果是多线程程序，需要使用线程代码，来保证同步
3. 集合元素可以为null
4. HashSet 集合判断两个元素相等是通过两个对象执行equals()方法比较并且两个对象的hashCode()方法返回值也要相等。

补充： hash 算法的功能 - hash算法的价值在于速度，它可以保证查询速度被快速执行。当需要查询集合中某个元素的时候，hash算法可以直接根据该元素计算出该元素的存储位置，从而可以让程序快速定位该元素。

HashSet中每个能存储元素的“槽位”通常称为“桶”，如果有多个元素的hashCo de值相同，但他们通过equals()方法返回false,这样一个“桶”里面就会放多个元素，会导致性能下降。

LinkedHashSet

是HashSet的子类，与父类的不同在于该类使用链表维护元素的次序，这样使得元素看起来是按照插入顺序保存的。
LinkedHashSet是因为使用了链表维护元素的次序，因此性能相对低于父类，但是迭代访问的时候将会有很好的性能。

TreeSet

TreeSet可以确保集合元素处于排序状态（排序状态指的是根据值的实际大小），除了haseset的方法之外，treeset提供了一些额外的方法

• Comparator comparator() 如果truest 采用了定制的排序，则该方法返回定制排序所使用的Comparator ,如果采用的是自然的排序，那么这个方法返回null
• first() 返回集合元素中的第一个元素
• last() 返回集合元素中的最后一个元素
• lower(object e) 返回集合元素中位于指定元素之前的元素（即小于指定元素的最大元素）
• higher(object e) 返回集合中位于指定元素之后的元素 （即大于指定元素的最小元素）
• subSet(from,to) 返回集合的子集合，范围从from 到to
• headSet(toele) 返回集合的子集，由小于toele的元素组成
• tailSet(fromele) 返回集合的子集，由大于或等于fromele的元素组成

treeset的排序

TreeSet 按照红黑树的数据结构进行存储，支持两种排序。
如果想要在集合treeSet中添加对象的话，该对象就需要实现Comparable接口。
comparable该接口定义了一个compareTo(Object obj)方法，该方法返回一个整数值。obj1.compareTo(obj2)如果该方法返回0，则表明这两个对象是相等的，如果返回一个正整数，则表明obj1 大于obj2，如果该方法返回一个负整数，则表明obj1小于obj2。

• 自然排序
  默认情况下是按照自然排序的方法进行排序的，即比较集合的大小，然后按照升序排列。
  注意：如果添加的对象的比较是根据一个可变Field的字段，进行比较的情况。
  如果是修改了Field字段，再次试图删除该对象的时候，Treeset里面的元素处于无序的状态，删除一个没有改变过的数据后集合中的元素会进行重新索引，接下来就可以删除集合中的所有的元素了。
• 定制排序
  如果实现定制排序，则可以通过Comparator 接口的帮助。该接口里包含一个in t compare(T o1,T o2)方法，该方法可以用于比较o1和o2的大小。如果需要实现定制排序，则需要在创建TreeSet集合对象的时候，提供一个Comparator对象与该TreeSet 集合关联。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

public class M {
 int age ;
 public M(int age){
	 this.age = age;
 }
 public String toString() {
	 return "M[age:"+age+"]";
 }
}


import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetTest4 {
	public static void main(String[] args) {
		TreeSet<M> ts = new TreeSet<M>(new Comparator<M>() {
			@Override
			public int compare(M o1, M o2) {
				// TODO Auto-generated method stub
				M m1 = o1;
				M m2 = o2;
				return m1.age>m2.age?-1:m1.age <m2.age?1:0;
			}
			
		});
		
		ts.add(new M(5));
		ts.add(new M(-3));
		ts.add(new M(9));
		System.out.println(ts);
	}

}

EnumSet类

EnumSet是一个专门为枚举类设计的集合类，EnumSet中的所有元素必须是指定枚举类型的枚举，集合元素是有顺序，顺序是由定义顺序决定的。

EnumSet内部是以位向量的形式存储的，这种存储形式非常高效，占用内存小，运行效率好，进行批量操作的执行速度非常快。

EnumSet 集合不允许加入null元素。
EnumSet 类没有暴露任何构造器来创建该类的实例，程序应该通过它提供的static方法来创建EnumSet对象。

EnumSet类提供了如下常用的static方法来创建对象

• allof(Class ele)：创建一个包含指定枚举类里所有枚举值的EnumSet集合
• complementOf(EnumSet s) 创建一个其元素类型与指定EnumSet里元素类型相同的EnumSet集合
• copyOf(Collection c) 使用一个普通集合来创建EnumSet集合
• copyOf(EnumSet s) 创建一个与指定EnumSet 具有相同元素类型、相同集合元素的EnumSet集合
• noneOf(Class elementType) 创建一个元素类型为指定枚举类型的空EnumSet
• range(E from ,E rest) 创建包含一个或多个枚举值的EnumSet 集合，传入的多个枚举值必须属于同一个枚举类
• of(E first,E rest) 创建一个包含一个或多个枚举值的EnumSet集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

mport java.util.EnumSet;

enum season{
	Sp,Sum,Fal,Win
}

public class TreeSetTest4 {
	public static void main(String[] args) {
		EnumSet es1 = EnumSet.allOf(season.class);
		System.out.println(es1);
		
		EnumSet es2 = EnumSet.noneOf(season.class);
		System.out.println(es2);
		
		es2.add(season.Sp);
		System.out.println(es2);
		
		EnumSet es3 = EnumSet.complementOf(es1);
		es3.add(season.Fal);
		System.out.println(es3);
	}
}

** 当试图复制一个Collection集合里面的值的时候来创建EnumSet集合时，必须保证Collection集合里面的元素都是同一个枚举类的枚举值。

set类的性能分析以及使用决策

• HashSet总是比TreeSet好，特别是常用的添加、查询元素。只有当需要维持一个排序的集合的时候才选择TreeSet.
• HashSet与Lin kedHashSet的比较：hashSet的插入、删除操作要更快一些。LinkedHashSet的遍历操作会更快一些。
• EnumSet 是所有Set实现类中性能最好的，但是只能保存同一个枚举类的枚举值作为集合元素。
• 三个实现类都是线程不安全的，如果有多个线程访问set的时候，则必须手动保证该Se t集合的同步。
  通常可以使用synchronizedSortedSet方法来包装

  1	SortedSet s = Collections.synchronizedSortedSet(new TreeSet());

List集合

Lsit集合代表一个元素有序、可重复的集合，集合中每个元素都有其对应的顺序索引。list集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。
List集合可以使用collection集合的所有操作方法。
list里面增加了一些根据索引来操作集合元素的方法。

• void add(int index ,obj ele)
• boolean addAll(int index,Collection c )
• object get(int index) 返回集合index索引处的元素
• int indexOf(Object o) 返回对象o 在list集合中第一次出现的位置索引
• int lastIndexOf(obj o) 返回对象o在list中最后一次出现的位置索引
• obj remove(int index) 删除并返回index索引处的元素
• List subList(int fromIndex,int toIndex) 返回从索引fromIndex 到索引toIndex处所有集合元素组成的子集合
• Object set(int index,Object element) 将index索引处的元素替换成element对象
  当调用List集合的set的方法的时候，指定的索引必须是Lis t集合的有效索引，不能添加一个大于list长度的索引值。
• • 集合元素判断两个元素相等的方式是 equals 方法。
    equals判断相等的方法是值相等，== 判断相等的方法是指向同一个对象。

list还额外提供了一个listIterator()方法，该方法返回一个ListIterator对象,增加了下面的方法

• boolean hasPrevious() 返回该迭代器关联的集合是否还有上一个元素
• Object previous() 返回该迭代器的上一个元素
• void add() 在指定的位置增加一个元素

  ArrayList和Vector实现类

  （vector 是一个古老的集合，有很多缺点，不建议使用，Ar ra yList是线程不安全的，Vector是线程安全的）
• 完全支持前面提到的List接口的全部功能
• 都是基于数组实现的List类
• 这两个对象都是使用initialCapacity 参数来设置数组的长度，当数组的长度改变的时候可以initialCapacity回自动增加
• void ensureCapacity(int minCapacity) 当向实现类中增加大量的元素的时候，该方法可以一次性的增加mincapacity大小的
• void trimToSize() 调整ArrayList或vector集合的Obj[] 数组长度为当前元素的个数。减少使用空间
• vector 集合实现了一个Stack的子类。实现了栈的方法，peek(),pop(),push()方法。

  固定长度的List

  前面讲数组的时候介绍了一个操作数组的工具类：Arrays,该工具类里提供了asList(object …a) 方法，该方法可以把一个数组或指定个数的对象转换成List集，这个list既不是ArrayList实现类的实例，也不是Vector实现类的实例，而是Arrays的内部类ArrayList的实例。
  Arrays.ArrayList是一个固定长度的List集合，程序只能遍历访问该集合里面的元素，不能增加、删除该集合里面的元素。

  1 2 3 4 5 6

  List fixedList = Arrays.asList("疯狂Java讲义","轻量级Java EE企业级应用实战"); System.out.println(fixedList.getClass()); for(int i=0;i<fixedList.size();i++) { System.out.println(fixedList.get(i)); } //试图增加、删除元素都会引发异常

Queue集合

用于模拟队列这种数据结构，队列通常是指“先进先出”的容器。

Queue接口中定义了以下几个方法：

• void add(Object e): 将指定元素加入到这个队列的尾部
• Object element(): 获取队列头部的元素，但是不删除队列中该元素
• boolean offer(Object e) 将指定元素加入到此队列的尾部
• Object peek() 获取队列头部的元素 但是不删除该元素，队列为空就返回null
• Object poll() 获取队列头部元素，并且删除这个元素

Queue接口有一个PriorityQueue 实现类。Queue还有一个Deque接口，Deque代表一个“双端队列”,双端队列可以同时从两端来添加、删除元素。

PriorityQueue实现类

这个队列是一个比较标准的队列实现类，之所以说它是比较标准的队列实现，是因为这个队列的保存不是按照加入队列的顺序保存的，而是按照队列元素的大小进行重新排序，取出的时候是先取出元素最小的那个元素，而不是首先插入的元素。(在这个意义上已经违背了队列的先进先出)

1
2
3
4
5
6
7
8

PriorityQueue<Integer> pro = new PriorityQueue<Integer>();
	pro.offer(3);
	pro.offer(9);
	pro.offer(1);
	System.out.println(pro);
	System.out.println(pro.poll());
	System.out.println(pro.poll());
	System.out.println(pro.poll());

1
2
3
4

[1, 9, 3]
1
3
9

可以发现，如果是直接输出队列的话，会使用toString()返回值，受String的影响，会导致输出的序列没有按照顺序输出，但是如果我们使用poll()的话，就是按照从小到大的顺序。

PriorityQueue 不允许插入null元素，因为它需要对队列中元素进行排序。

• 自然排序
  自然排序的元素必须实现了Comparable接口。
• 定制排序
  创建PriorityQueue队列的时候，传入一个Comparator 对象，该对象负责对队列中的所有元素进行排序，不要求队列元素实现Comparator的接口。

  Deque 接口与ArrayDeque实现类

  Deque接口是Queue接口的子接口，代表了一个双端队列，允许从两端来操作队列的元素。可以当作双端队列或者栈使用
• addFirst()
• addLast()
• Iterator descendingIterator() 返回该双端队列对应的迭代器，该迭代器按照逆向顺序迭代队列
• getFirst()
• getLast()
• offerFiirst()
• offerLast()
• peekFirst()
• peekLast()
• pollFirst()
• pollLast()
• pop() 相当于removeFirst
• push() 相当于addFirst
• obj removeFirst() 获取并删除该双端队列的第一个元素
• obj removeFirstOccurrence(obj o) 删除该双端队列的第一个出现的元素o
• removeLast()获取并删除该双端队列的最后一个元素
• removeLastOccurrence(obj o) 删除该双端队列最后一次出现的元素o
  ArrayDeque是Deque的基于数组的实现类。

  LinkedList

  是List接口的实现类，意味着这是Lis t的一个集合，可以根据索引来随机访问集合中的元素，还实现了De que接口，因此也可以当作双端队列使用，也可以当作栈使用。

LinkedList是一个功能非常强大的集合，与ArrayList以及ArrayDeque的实现机制完全不同，Array是按照数组形式来保存数据的，因此在访问集合元素的时候性能比较好，Linkedlist是根据链表来存储数据的，访问数据的时候性能比较差，但是在插入、删除元素的时候性能比较好。

各种线性表的性能分析

java堆内存大小的修改

1

java -Xms128m -Xmx512m PerformanceTest

-Xms 表示设置的JVM的堆内存的初始大小
-Xmx 表示设置的JVM的堆内存的最大大小（不要超过物理内存）

使用建议

• 如果是遍历List集合
  • ArrayList、Vector使用get来遍历集合元素
  • LinkedList集合 使用迭代器遍历
• 如果需要经常执行插入删除 操作 则使用LinkedList。如果使用ArrayList或者Vector的话，通常需要重分配内部数组的大小，时间开销经常是LinkedList的几十倍。
• 多线程访问集合的时候，应该考虑集合的线程安全集合

Map

map的key是不允许重复的，在一个Map对象的任何两个key通过equals方法比较总是返回false。
Set与Map的关系非常的密切，从源码来看，Java是通过先实现了Map，然后通过包装一个所有value都为null的Map就实现了Set集合。
通用方法总结
-clear() 删除该Map对象中所有的key-value对

• bool containsKey()
• bool containsValue()
• Set entrySe() 返回Map集合中所有的key-value对
• obj get(key)
• isEmpty()
• Set keySet()
• obj put(key,value)
• void putAll(map)
• obj remove(key)
• int size()
• Collection values()

map中的每一个实体类的方法：

• obj getKey()
• obj getValue()
• obj setValue()

  HashMap 和 Hashtable实现类

  HashTable与HashMap都是Map接口的典型实现，它们之间的关系类似于ArrayList与Vector的关系。HashTable是一个古老的Map实现类。
  区别：
• Hashtable是一个线程安全的实现，HashMap是线程不安全的。
• Hashtable不允许使用null作为key和value ,HashMap是可以的。
  Hashtable和HashMap类用作key的对象都必须实现hashCode()方法和equals()方法。
  Hashtable与HashMap 列表判断值相等的方法是equals()方法

  LinkedHashMap

  LinkedhashMap 使用双向链表来维护key-value对的次序，该链表负责维护Map的迭代顺序，保证顺序与插入的链表一致。

  Properties 读写属性文件

  （windows中的ini文件就是一种属性文件）
  Properties 类是Hashtable 类的子类，该对象在处理属性文件的时候特别方便。该类可以把Map 对象和属性文件关联起来，从而可以把Map对象中的key-value 对写入属性文件中，也可以把属性文件中的“属性名= 属性值”加载到Map 对象中。
  一共有三个方法修改Properties里面的key和value值
• String getProperty(String key) : 获取属性文件中指定属性名对应的属性值
• String getProperty(String key,String defaultValue) 如果文件中不存在指定的key值的时候，会设置default作为默认值。
• Object setProperty(String key,String value) 设置属性
• void load(InputStream inStream) 从属性文件中加载key-value对，把加载到的key-value对追加到Propertie里面，不保证次序
• void store(OutputStream out,String ) 将properties 中的key-value对输出到指定的属性文件中。

这里提供一个读取java中的properties文件的示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public static void main(String[] args) {
		Properties pro = new Properties();
		try {
		// 读取
			pro.load(new FileInputStream(new File("./pro.properties")));
			String xx = pro.getProperty("ee");
			System.out.println(xx);
			pro.setProperty("p", "12323");
			System.out.println(pro.getProperty("p"));
			//存储
			pro.store(new FileOutputStream(new File("./pro.properties")),"test line");
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

SortedMap接口和TreeMap实现类

SortedMap接口也有一个TreeMap的实现类，TreeMap就是一个红黑树数据结构，每个key-value对即作为红黑树的一个节点。TreeMap存储key-value对的时候，需要根据key对节点进行排序。TreeMap可以保证所有的key-value对处于有序状态。

• 自然排序
  key必须实现Comparable接口，而且所有的ke y应该是同一个类的对象。

• 自定义排序
  创建Treemap的时候，需要传入一个Comparator对象，该对象负责对Treemap 中的所有的key进行排序。

  如果使用自定义作为Treemap的key的时候，如果想要让TreeMap良好的工作，则重写该类的equals()方法和compareTo()方法时保持一致的返回结果，两个key 通过equals()方法比较返回true时，它们通过compareTo()方法。

• Map.Entry firstEntry()：返回该Map中的最小值，如果该Map为空或不存在这样的key，则都返回null

• firstKey() 返回该Map中最小key值，如果该Map为空，则返回null
• Map.Entry lastEntry(): 返回map中最大key值
• Map.Entry higherEntry(obj key) 返回该Map中位于后一位的key-value 对。如果该Map为空，则返回null
• Object higherKey(object key) 返回该Map中位于key后一位的key值
• Map.Entry lowerEntry(obj key) 返回该Map中位于key 前一位的key-value对
• Object lowerKey(obj key) 返回该Map中位于key前一位的ke y值
• NavigableMap subMap(obj fromkey, bool from, obj toKey ,bool toin) 返回map的子集，是否包含fromKey 与 toKey主要取决于 后面的bool值
• SortedMap tailMap(obj fromKey) 返回map的子map,其key 的范围是大于fromKey的。
• SortedMap headMap(obj toKey) 返回该map的子Map,其key的范围是小于hokey的所有的key
• Navigatable headMap(obj tokey,bool inclu) tokey是否包含取决于bool的值

  weakHashMap实现类

  与HashMap的用法是一样的，只不过HashMap是强引用的，只要HashMap对象不被销毁，那么所有的key就都不会被垃圾回收机制回收，也不会自动删除这些key对应的key-value对。但是weakHashMap是弱引用的，如果该对象的key 没有被强引用变量引用，则这些key所引用的对象可能被垃圾回收，也可能自动删除这些key 所对应的key-value对。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  public class test { public static void main(String[] args) { WeakHashMap<String, String> whm = new WeakHashMap<String, String>(); whm.put(new String("语文"), new String("良好")); whm.put(new String("数学"), new String("及格")); whm.put(new String("英文"), new String("中等")); System.out.println(whm); whm.put("java","dsdfs"); System.gc(); System.runFinalization(); System.out.println(whm); } } //结果 {英文=中等, 数学=及格, 语文=良好} {java=dsdfs}

从上面的程序中，我们可以看出，在系统进行垃圾回收的时候，前面new的对象全部被回收了，但是使用字符串java的变量还在，这是因为前面三个都是匿名的对象，weakHashMap只保留了它的弱引用，但是第四个的key是一个字符串直接量，系统会保留它的强引用，所以垃圾回收机制不会回收。

IdentityHashMap实现类

这个实现类与HashMap的类是实现机制是相同的，主要的区别在于当且仅当两个key严格相等的时候(key1 == key2)的时候，该类才能判定两个ke y相等。对于普通的HashMap而言，只要key1 和key2 通过equals()方法比较返回true,且它们的hashCode值相等即可。

EnumMap 实现类

EnumMap是一个与枚举类一起使用的map实现，EnumMap中的所有key必须是单个枚举类的枚举值。创建EnumMap的时候，必须显示或者隐示的指定它对应的枚举类。
根据key的自然顺序来维护key-value 对的顺序。
EnumMap 不允许使用null作为key，但是允许使用null作为value.
创建EnumMap的时候，必须指定一个枚举类，从而将该EnumMap和指定枚举类关联起来。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

import java.util.EnumMap;

enum Season{
	SPRING,SUMMER,FALL,WINTER
}

public class test {
public static void main(String[] args) {
	EnumMap<Season, String> sE = new EnumMap<Season, String>(Season.class);
	sE.put(Season.FALL, "dsdf");
	sE.put(Season.SPRING, "dsdfsd");
	System.out.println(sE);
 } 
}

Map实现类的性能分析

• HashMap与Hashtable的效率大致相同，实现机制几乎一样，但是Hashtable是线程同步的。
• TreeMap 通常比HashMap、Hashtable要慢，因为TreeMap 底层采用红黑树来管理。
• 对于一般的应用场景，程序应该多考虑使用HashMap，因为HashMap正是为查询设计的。
• LinkedHashMap比HashMap 慢一点，因为它需要维护链表来保持Map中的key-value时的添加顺序。

  HashSet 和 HashMap的性能选项

  对于HashSet及其子类而言，它们采用hash算法来决定集合中元素的存储位置，并通过hash算法来控制集合的大小；对于HashMap、Hashtable及其子类而言，它们采用hash算法来决定Map中key的存储，并通过hash算法来增加key集合的大小。
  hash表里面可以存储元素的位置被称为“桶”，通常情况下，单个“桶”里面存储一个元素，此时有最好的性能。

  操作集合的工具类：Collections

  Java提供了一个Set、List和Map的工具类：Collection,该工具类里面提供了大量的方法可以对集合进行排序、删除、查找、设置集合为不可变、对集合对象实现同步控制等方法。

  排序操作

• static void reverse(List list) 反转指定集合的元素
• static void shuffle(List list) 对集合元素进行随机排序
• static void sort(List list) 根据自然排序对集合进行升序排序
• static void sort(List list,Comparator c) 根据指定的规则对集合进行排序
• satic void swap(List list, int I,int j) 将指定的Lis t集合中的I处的元素和j处的元素进行交换。
• static void rotate(List list, int distance)
  • distance 为正数的时候，将list集合的后distance 个元素“整体”移到前面
  • 为负数的时候，将list集合的前distance 个元素整体移到后面
    使用语法：

    1 2 3 4 5 6 7

    List<Integer> ls = new ArrayList<Integer>(); ls.add(1); ls.add(2); ls.add(3); ls.add(4); System.out.println(ls); Collections.reverse(ls);

查找替换操作

• static int binarySearch(List list,Object key) 使用二分搜索方法 搜索指定的集合，获得指定对象在集合中的索引
• static Object max(Collect coll) 根据元素的自然排序，返回集合中的最大元素
• static Object max(Collection Coll,Comparator comp) 根据指定的排序方法，返回最大的值
• min 同理
• static void fill(List list,Object obj) 使用指定元素obj替换指定 List集合中的所有元素
• static int frequency(Collection c ,Object o) 返回指定集合中指定元素出现的次数
• static int indexOfSubList(List source,List target): 返回子list对象在父List对象中第一次出现的位置索引；如果父List中没有出现，则返回-1
• static int lastIndexOfSubList(List source,List target) 返回子List对象在父List中最后一次出现的位置索引
• static boolean replaceAll(List list,Object oldVal,Object newVal) 使用一个新值newVal替换List对象的所有旧的oldVal

  同步控制

  Collections类中提供了多个synchronizedXxx() 方法，可以将指定的集合包装成线程同步的集合

  1 2	Collection c = Collections.synchronizedCollection(new ArrayList()) List ls = Collections.synchronizedList(new ArrayList());

设置不可变对象

• emptyXxx() 返回一个空的、不可变的集合对象
• singletonXxx() 返回一个只包含指定对象的、不可变的集合对象
• unmodiifiableXxx() 返回指定集合对象的不可变视图
  上面的意思是生成的集合只能读取

购买华为云RDS

登陆华为云账号，在右上角有一个 购买数据库实例，点击即可。
购买成功后，回在控制台显示实例名称，然后输入用户名以及密码登陆即可。

在 MySQL 数据库建立一个海洋环境信息表，存储某一地点不同日期一天中不同时间的海洋观测数据，包括日期，时间，经度，维度，风向，风速，压力，温度，温度。

我们可以在登陆的首页处先点击创建一个数据库

然后创建完毕后，点击数据库的名字，进入到该数据库里面去，在数据库里面建立一张数据表名！两种方式创建

• 可以通过点击创建数据表进行创建，需要填写表名，以及字符集（这里我们使用utf-8字符集就可以了）
  

• 通过执行sql语句进行创建(操作不熟练的，直接操作界面更方便一些）
  如果想要使用Sql语句进行执行，可以点击页面头部的Sql窗口按钮。这样就可以通过sql语句进行执行了。

经过上面的操作，我们已经拥有一张自己的表格了。

将 Excel 表格的海洋环境数据导入本地 MySQL 数据库。迁移 MySQL 数据，把本地海洋观测MySQL 数据库迁移到华为云数据库。

首先我们先要在本地安装navicat数据库 图形化界面工具。关于这个工具，我就不再赘述了。网上有很多的使用教程。安装配置好之后，在自己 创建的数据库中，点击文件-> 导入向导->然后选择自己要导入的对应的数据文件即可。

在接下来的操作中，如果你是想尝试第一种方式，那么就在navicat中导出数据库文件为d b文件或者csv文件。如果是想尝试第二种方法就导出为sql脚本可执行文件，然后使用文本编辑器打开即可。

方式一 通过导入本地的数据库，然后使用OBS桶进行数据库迁移

可以看到这个位置有一个导入的按钮 ，我们点击进去，然后新建一个导入的位置

可以看到这里有一个OBS桶，如果没有的话，我们自己创建一个就可以了。然后点击或将文件拖动到此处后上传文件字样，就可以创建一个导入任务了。（这里我没有导入成功）

方式二 手动通过Sql语句导入

将导出的s q l可执行语句，放入到华为数据库的SQL查询处执行SQL语句。就将数据导入进去了。但是在导入的过程中，出现了一个问题，就是我们在建立表的时候，建立的是有id的数据表，但是我们在本地建设数据库的时候并没有包含着一列。因此，我们要修改一下表，删除第一列id。在执行语句。

然后等待执行结束就可以了！

这样我们的数据库的内容，就全部迁移过去了,有点费劲。现在有个问题就是，这样我们的数据集就没有了主键。因此就不能进行编辑操作。因此，我们需要返回对象列表，点击修改表，点击修改字段部分，然后在第一行插入一个字段，我们称之为id。然后将这一列设置为主键，并且自动增长。

这样我们的数据库的操作就完成了。

当然数据库迁移的方式还有很多很多，比如我们可以直接写一个程序从本地数据库读取，然后往华为数据库添加，也是可以的。或者华为云提供的其他的迁移方式。

求每天最大风速的时间和风向（结果可能多条记录）

1
2
3
4
5
6
7
8

SELECT OBDATE, Time, WIND_SPD, WIND_DIR
FROM marinedata m1
WHERE WIND_SPD IN (
	SELECT MAX(WIND_SPD)
	FROM marinedata m2
	WHERE m1.OBDATE = m2.OBDATE
	GROUP BY OBDATE
);

我用的数据集的结果为：

求每天最小风速的时间和风向（结果可能多条记录）

1
2
3
4
5
6
7
8

SELECT OBDATE, Time, WIND_SPD, WIND_DIR
FROM marinedata m1
WHERE WIND_SPD IN (
	SELECT MIN (WIND_SPD)
	FROM marinedata m2
	WHERE m1.OBDATE = m2.OBDATE
	GROUP BY OBDATE
);

求温度最低时的时间，风速和风向

1
2
3
4
5
6
7
8

SELECT OBDATE, Time, WIND_SPD, WIND_DIR
FROM marinedata m1
WHERE TEMPERATURE_DB  IN (
	SELECT MIN (TEMPERATURE_DB )
	FROM marinedata m2
	WHERE m1.OBDATE = m2.OBDATE
	GROUP BY OBDATE
);

求温度最高时的时间，风速和风向

1
2
3
4
5
6
7
8

SELECT OBDATE, Time, WIND_SPD, WIND_DIR
FROM marinedata m1
WHERE TEMPERATURE_DB  IN (
	SELECT MAX(TEMPERATURE_DB )
	FROM marinedata m2
	WHERE m1.OBDATE = m2.OBDATE
	GROUP BY OBDATE
);

求平均风速和温度

1
2

SELECT AVG(WIND_SPD) AS Average_WIND_SP, AVG(TEMPERATURE_DB) AS Average_Temp
FROM marinedata

求温差最大的日期

1
2
3
4
5
6

SELECT OBDATE, Time, TEMPERATURE_DB - TEMPERATURE_DP AS DIFF
FROM marinedata
WHERE TEMPERATURE_DB - TEMPERATURE_DP = (
	SELECT MAX(TEMPERATURE_DB - TEMPERATURE_DP)
	FROM marinedata
);

用户权限控制

练习创建不同的用户，并实现不同的权限控制语句

• 界面操作
  其他操作->用户操作
  
  主机地址表示允许通过此用户访问数据库服务器的客户端IP地址白名单，不填或填%表示所有IP地址。
  
  这里我们可以看到一些对全局表的操作权限设置。这里我配置一个select的权限测试一下。

如果想要对某一个数据库进行权限赋予，则需要在对象权限里面进行编辑，如果想要针对某一个表的话，则需要在表/视图里面进行勾选，选择相应的表格即可。

这里我选择了 select 和 Delete的权限

然后返回到登陆界面，新增一个数据库登陆，将我们刚刚新添加的数据库的登陆添加上，测试连接成功后即可使用。

现在我执行一个updata操作，看结果

1
2
3
4
5

---------------开始执行---------------
【拆分SQL完成】：将执行SQL语句数量：（1条）
【执行SQL：(1)】
UPDATE marinedata SET TEMPERATURE_DB =0 WHERE id =1
执行失败，失败原因：UPDATE command denied to user '666'@'***' for table 'marinedata'

可以看到，执行失败了，因为我没有给这个表赋予updata权限。
我们在执行一个select的操作，查询id为2的数据

可以看到我们已经执行成功了。

• 语句操作

1
2
3
4
5
6
7
8
9

/*COMMON SETTINGS
创建一个用户，666代表用户名，100.% 表示所有的ip地址都可以访问，我们也可以换成指定的ip地址。identified by表示的是用户的密码
*/
CREATE USER '666'@'100.%' IDENTIFIED BY '******';

/*GLOBAL SETTINGS
权限分配的语句为GRANT，这条语句的意思是将SELECT这个权限给所有的表，用户为666这个用户
*/
GRANT SELECT ON *.* TO '666'@'100.%';

权限授权和回收

权限授权上面已经说了，权限回收的界面操作，按照上面的步骤将勾选的权限删除掉即可。
使用语句进行权限回收-

1

REVOKE SELECT ON *.* FROM '666'@'100.%';

【拆分SQL完成】：将执行SQL语句数量：（1条）
【执行SQL：(1)】
REVOKE SELECT ON . FROM ‘666‘@’100.%’
执行成功，耗时：[13ms.]

这样权限就回收了

BOM

Browser Object Model(浏览器对象模型)
JS是由浏览器中内置的js脚本执行解释器程序来执行js的脚本语言的。
为了方便操作，js封装了对浏览器的各个对象使得开发者可以方便的操作浏览器。

window对象

是javascript层级中的顶层对象，是代表浏览器窗口或一个框架，该对象在或者每次出现的时候都被自动创建。

• moveto() 将窗口左上角的屏幕位置移动到指定的x和y位置
• moveby() 相对于目前的位置移动
• resizeTo() 调整当前浏览器的窗口
• open() 打开新的窗口显示指定的URL
• setTimeout(vCode,iMilliseconds) 超时后执行代码
• setInterval(vCode,iMilliSeconds) 定时执行代码，第一次也是先到执行时在执行

  事件

  所有的事件都是以o n开头，后面的是事件的触发方式。如：
  o’clock 表示单击
  onkeydown 表示键按下

鼠标点击事件

• o’clock 用户使用鼠标左键单击对象的时候触发
• ondbclick 当用户双击对象的时候触发
• onmousedown 当用户在鼠标位于对象之上的时候，释放鼠标按钮时候触发
• onmouseout 当用户将鼠标指针移出对象边界的时候触发
• onmousemove 当用户将鼠标划过对象的时候触发
• onblur 在对象失去输入焦点的时候触发
• onfocus 当对象获得焦点的时候触发
• onchange 当对象或选中区的内容改变的时候触发
• o load 在浏览器完成对象的装载后立即触发

• o submit 当表单将要被提交的时候触发

  location对象

  location对象是由js runtime engine自动创建的，包含有关当前URL 的信息。
  location 中的重要方法：

  href 属性 设置或获取整个 URL 为字符串
  reload（）重新装入当前页面
  

  screen 对象

  js自动创建的，包含有关客户机显示屏幕的信息
  属性：

  • availHeight 获取系统屏幕的工作区域高度 ，排除任务栏
  • availWidth 获取系统屏幕的工作区域的宽度 排除任务栏
  • height 获取屏幕的垂直分辨率
  • width 获取屏幕的水平分辨率

  案例：

1
2

document.write("屏幕工作区: " + screen.availHeight + ", " + screen.availWidth + "<br>");
	document.write("屏幕分辨率: " + screen.height + ", " + screen.width + "<br>");

document 对象

该对象代表整个文档页面
对象的集合：

• all 获取页面所有的元素对象
• forms 获取页面所有的表单对象
• images 获取页面所有的图片对象
• links 获取所有的超链接 或者area对象

  DOM

  全称Document Object Model 即文档对象模型。
  该模型描绘了一个层次化的树，允许开发人员添加、删除、修改页面的某一部分。
  浏览器在解析HTML的时候，其实不是按照一行一行读取并解析的，而是将HTML页面中的每一个标记按照顺序在内存中组建一颗DOM树，组建好之后，按照树的结构将页面显示在浏览器窗口中。

节点最多有一个父亲节点，可以有多个子节点。
HTML DOM 定义访问和操作HTML 文档的标准方法。

• document 代表当前页面的整个文档树

• 访问属性

  • all
  • forms
  • images
  • links
  • body

  访问方法（最常用的是DOM方法）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

<script type="text/javascript">
      //获取Dom树 获取document对象
      var dom  = window.document;
      //获取界面的所有元素
      function testAll() {
          var allarr = dom.all;
          alert(allarr.length);
          for (var  i =0;i<allarr.length;i++){
              //获取节点的名字
              alert(allarr[i].nodeName)
          }
      }
      //anchors 获取页面中的所有锚连接
      function testAnchors() {
          var anaArr = dom.anchors;
          alert(anaArr.length);
          alert(anaArr[0].nodeName);
      }
      //获取所有的form对象
      function testForms() {
          var formARR = dom.forms;
          alert(formARR.length)
      }
      //images
      function testimage() {
          var ima = dom.images;
          alert(ima.length)
      }
      //获取页面的所有连接
      function testlinks() {
          var lin = dom.links;
          alert(lin.length)
      }

  </script>

获取节点对象的案例

1
2
3
4
5
6
7
8
9
10
11
12

function getobj(){
            //根据标签id获取对象
            var a = document.getElementById("1")
            alert(a.nodeName)
           //根据标标签属性名称获取对象
            var b = document.getElementsByName("bu")
            alert(b.length)

            //根据标签名称获取对象
            var c = document.getElementsByTagName("p")
            alert(c.length)
        }

通过节点关系查找节点

//从一个节点开始出发 进行查找

• parentNode 获取当前节点的父亲节点
• childNodes 获取当前节点的孩子节点
• firstChild 获取当前节点的第一个孩子节点
• lastChild 获取当前节点的最后一个孩子节点
• nextSibling 获取当前节点的兄弟节点
  注意这个有一个隐藏的文本标签
• previousSibling 获取当前节点的上一个节点

  获取节点对象的信息

  每个节点都包含的信息的，这些属性是：
• nodType 节点类型
• 元素 返回1
• 文本 返回3
• 注释 返回8
• nodeName 节点名称
• 元素节点的nodeName是标签的名称
• 属性节点的nodeName是属性名称
• 文本节点的nodeName 永远是#text
• 文档节点的nodeName 永远是#document
• nodeValue 节点值
• 对于文本节点 nodeValue 属性是包含的文本
• 对于属性节点 nodeValue属性是属性值
• 对于注释节点 nodeValue属性注释内容
• nodeValue属性对文档节点和元素节点是不可用的

  节点操作

  创建新的节点

• document.createElement(“标签名”) 创建新元素节点
• elt.setAttribute(“属性名”,”属性值”）设置属性
• elt.appendChild(e)
• elt.insertBefore(new,child) 添加到elt中，child之前
• elt.removeChild(eChild) 删除指定的子节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script type="text/javascript">
       var count =1;
       function add() {
           var trNode = document.createElement("tr");
           var tdNode = document.createElement("td");
           var inputNode  = document.createElement("input");
           inputNode.setAttribute("type","button");
           inputNode.setAttribute("value",count++);
           count++;
           tdNode.appendChild(inputNode);
           trNode.appendChild(tdNode);
           //trNode添加到指定的位置上
           var tbodyNode = document.getElementsByTagName("tbody")[0];
           var button1 = document.getElementById("b1");
           tbodyNode.insertBefore(trNode,button1);
       }
    </script>
</head>
<body>
  <table>
      <tr>
          <td>
              <input type="button" value="0" >
          </td>
      </tr>
      <tr id="b1">
          <td>
              <input type="button" value="添加" onclick="add()">
          </td>
      </tr>
  </table>
</body>
</html>

几个小案例

生成二级城市联动菜单

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>二级联动菜单</title>
    <script type="text/javascript">
        function selcity() {
            //每一个省建立一个二维数组
            var arr = [['--选择城市--'],['海淀区','朝阳区','东城区','西城区']
                ,['沈阳','大连','鞍山','抚顺']
                ,['济南','青岛','烟台','威海']
                ,['石家庄','廊坊','唐山','秦皇岛']];
            //获取选择的省的角标
            var selNode = document.getElementById("selid");
            var index = selNode.selectedIndex;
            var cities = arr[index];
            var subSelNode = document.getElementById("subselid")
            //清除下拉菜单的内容
            subSelNode.options.length = 0;
            for(var x =0;x<cities.length;x++){
               var optNode = document.createElement("option");
               optNode.innerHTML = cities[x];
               subSelNode.appendChild(optNode);
            }
        }
    </script>
</head>
<body>
  <select id="selid" onchange="selcity()">
      <option>--选择省市--</option>
      <option>北京市</option>
      <option>辽宁省</option>
      <option>山东省</option>
      <option>河北省</option>
  </select>
  <select id="subselid">
      <option>--选择城市--</option>
  </select>
</body>
</html>

生产一个验证码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>验证码</title>
    <script type="text/javascript">
      function createCode() {
          var datas = ["A", "B", "C", "D", "E", "F", "G", "H", "Z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];
          //随机从数组中取出4个元素
          var mess = "";
          var index = 0;
          for (var i = 0; i < 4; i++) {
              //生成随机数 而且是在数组的长度范围内
              //0-9 之间的随机数，Math.floor(Math.random()*10)
              //0到数组长度（不包含）之间的浮点数 向下取整
              var index = Math.floor(Math.random() * datas.length);
              mess += datas[index];
          }
          ;
          var codeSpan = window.document.getElementById("codeSpan");
          codeSpan.style.color = "red"
          codeSpan.style.fontSize = "20px"
          codeSpan.style.background = "gray"
          codeSpan.style.fontStyle = "italic"
          codeSpan.style.textDecoration = "line-through"
          codeSpan.innerHTML = mess;
          codeSpan.value = mess;
      }
    </script>
</head>
<body onload="createCode()">
   <span id="codeSpan"></span><a href="#" onclick="createCode()">看不清楚</a>
</body>
</html>

从JKD5开始，java增加了对元数据的支持，也就是Annotation,这是代码里的特殊标记，这些标记可以在编译、类加载、运行的是时候被读取，并且能够执行相应的处理。
通过使用Annotation ，我们可以在开发过程中，在不改变原有逻辑的情况下，在源文件中补充一些信息。
Annotation 可以用于修饰包、类、构造器、方法、成员变量、参数和局部变量的声明。

四个基本的Annotation

@Override (重写父类方法)

用来指定方法覆载的，它可以强制一个子类必须覆盖父类的方法。
在使用这个注解的时候，可能看不出来效果，这个的主要作用是检查一下父类中，是不是有一个相同的方法被重写！

@Deprecated(标示已经过时)

用于表示某个程序元素已经过时，当其他程序使用已经过时的类、方法的时候，编译器将会给出警告。

@SuppressWarnings(抑制编译器警告)

指示被该Annotation修饰的程序元素取消显示指定的编译器警告，会一直作用于该程序元素的所有子元素。在使用的过程总，一定要在括号里面使用name = value的形式 ！即 @SuppressWarnings(value = “unchecked”)
unchecked就是一个未经过检查的转换

java7 的堆污染警告@SafeVarargs

当把一个不带范型的对象赋给一个带范型的变量的时候，往往就会发生“堆污染”。例如：

1
2

List list = new ArrayList<Integer>();
list.add(20);

对于形式参数可变的方法，该形参类型又是范型，这将更容易导致“堆污染”。
（java不支持范型数组）

JDK基本的元Annotation

@Retention

只能用来修饰一个Annotation定义，用于指定被修饰的Annotation可以存活多长时间。后面必须跟着一个值（三个限定）
例如：

1
2

@Retention(value=RetentionPolicy.SOURCE)
public @interface Testtable{}

@Target

只能修饰一个Annotation定义，用于指定被修饰的Annotation能用于修饰哪些程序单元。(有八个程序变量的值)
例如：

1
2

@Target(ElementType.FIELD)
public @interface ActionListenerErro{}

@Documented

用于指定这个Annotation类可以被javadoc工具提取成文档.

1
2
3
4

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
//使用Documented修饰 一个类 用作Annotation ，这个类可以被javadoc工具提取成文档
public @interface Testtable{}

然后使用Testtable修饰 其他类的方法，就会被提取成文档

1
2
3
4
5
6
7
8

public class MyTest
{
@Testtable
public void info()
{
  System.out.println("info方法...");
}
}

@Inherited

如果定义某一个Annotation的时候，这个类被@Inherited修饰，则继承了该类的子类将会被@A修饰。

1
2
3
4

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface Inheritable{}

上面程序中粗体字代码表明@Inheritable 具有继承性，如果某个类使用了@Inheritable修饰，则该类的子类将自动使用@Inheritable修饰

1
2
3
4
5
6
7
8
9
10
11
12

@Inheritable
class Base[
}
//InheritableTest 类只继承了Base类
// 并未直接使用@Inheritable Annotiation修饰
public class InheritableTest extends Base[
public static void main(String [] args)
{
//打印InheritableTest类是否具有@Inheritable修饰
System.out.println(InheritableTest.class.isAnnotationPresent(Inheritable.class));
}
}

上面程序中的Ba se类使用@Inheritable修饰，而该Annotation具有继承性，所以其子类也将自动使用@Inheritable修饰。上面程序输出 true

自定义Annotation

自定义Annotation使用@interface关键字定义一个新的Annotation 类型与定义一个接口非常像。

标记Annotation(无参数)

1
2
3

//定义一个简单的Annotation
public @interface Test{
}

使用Annotation的时候，通常可以用来修饰程序中的类、方法、变量、接口等定义。通常Annotation放在所有的修饰符之前。

元数据Annotation(有参数)

1
2
3
4

public @interface mytage{
String name();
int age();
}

带有成员变量的Annotation 的定义是以无形参的方法形式来声明，其方法名和返回值定义了该成员变量的名字和类型。
在使用的时候，应该写为

1

@mytage(name="xx",age=6)

也可以设置默认值

1
2
3
4

public @interface mytage{
String name() default "yeeku";
int age() default 2;
}

提取Annotation信息

开发者使用Annotation 修饰了类、方法、Field等成员之后，这些Annotation不会自己生效，必须由开发者提供相应的工具来提取并处理Annotation信息。

java5在java.lang.reflect包下新增加了AnnotatedElement接口，该接口代表程序中可以接受注释的程序元素。
该接口主要有如下几个实现类：

• Class 类定义
• Constructor 构造器定义
• Field 类的成员变量定义
• Method 类的方法定义
• Package 类的包定义

程序可以通过调用某一个类的如下三种方法来访问Annotation信息

• getAnnotation(Class annoClass)
• Annotation[] getAnnotations() 返回该程序元素上存在的所有的注释
• boolean isAnnotationPresent(Class<? extends Annotation> annotationClass): 判断该程序上是否存在指定类型的注释，如果存在则返回true,否则返回false.
  例如：获取Test类的info 方法里面的所有的注释

1

Annotation [] aArray = Class.forName("Test").getMethod("info").getAnnotations()

使用Annotation 的示例

仅仅使用注释来标记程序元素是不会有任何影响的，为了让程序中的这些注释起作用，接下来必须为这些注释提供一个注释处理工具，注释处理工具通过分析目标类中的注释，然后在通过反射来运行标记的测试方法，程序可以做出相应的处理。

示例

在示例程序中通过使用@ActionListenerFor来为程序中的按钮绑定事件监听器

• 首先创建一个标记，该标记需要传入一个监听器实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

package AnnotationExample;

import java.awt.event.ActionListener;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ActionListenerFor {
  //定义一个成员变量，用于设置元数据
  //该listener 成员变量用于保存监听器实现类
	Class<? extends ActionListener> listener();
}

• 然后，创建两个监听器的实现类
  确认按钮实现类

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  package AnnotationExample; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JOptionPane; public class OkListener implements ActionListener{ @Override public void actionPerformed(ActionEvent e) { // TODO Auto-generated method stub JOptionPane.showMessageDialog(null,"单击了确认按钮"); } }

• 取消按钮实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

package AnnotationExample;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JOptionPane;

public class CancelListener implements ActionListener{

	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		JOptionPane.showMessageDialog(null,"单击了取消按钮");
	}
}

• 如果仅仅在程序中使用注释是不会起任何作用的，需要编写一个注释处理工具来处理程序中的注释

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

package AnnotationExample;

import java.awt.event.ActionListener;
import java.lang.reflect.Field;

import javax.swing.AbstractButton;

public class ActionListenerInstaller {
	//处理Annotation 的方法，其中obj是包含Annotation的对象
	public static void processAnnotations(Object obj)
	{
		try {
			Class cl = obj.getClass();
			//获取指定的obj 对象的所有Field 并遍历每个field
			for(Field f: cl.getDeclaredFields()) {
				//将指定的Field设置成可自由访问
				f.setAccessible(true);
				//获取指定Field 上的ActionListenerFor类型的Annotation
				ActionListenerFor a = f.getAnnotation(ActionListenerFor.class);
				//获取f Field 实际对应的对象
				Object fobj = f.get(obj);
				//如果f是AbstractButton 的实例，并且a不为null
				if(a!=null && fobj != null && fobj instanceof AbstractButton) {
					//获取a注释 里的元数据listener (它是一个监听器类)
					Class<? extends ActionListener> listenerClazz = a.listener();
					//使用反射来创建listener类的对象
					ActionListener al = listenerClazz.newInstance();
					AbstractButton ab = (AbstractButton)fobj;
					//为ab按钮添加事件监听器
					ab.addActionListener(al);
				}
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} 
	}
}

• 主程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package AnnotationExample;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class AnnotationTest {
	private JFrame mainWin = new JFrame("使用注释绑定事件监听器");
	//使用Annotation 为ok 按钮绑定事件监听器
	@ActionListenerFor(listener = OkListener.class)
	private JButton ok = new JButton("确定");
	@ActionListenerFor(listener = CancelListener.class)
	private JButton cancle = new JButton("取消");
    public void init()
    {
    	//初始化界面的方法
    	JPanel jp = new JPanel();
    	jp.add(ok);
    	jp.add(cancle);
    	mainWin.add(jp);
    	//
    	ActionListenerInstaller.processAnnotations(this);
    	mainWin.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    	mainWin.pack();
    	mainWin.setVisible(true);
    }
    public static void main(String[] args) {
		new AnnotationTest().init();
	}
}

编译时处理Annotation

APT（Annotation Processing Tool）是一种注释处理工具，它对源代码文件进行检测找出其中的Annotation后，对Annotation 进行额外的处理。
Annotation处理器 在处理Annotation的时候可以根据源文件中的Annotation生成额外的源文件和其他文件，APT还会编译生成的源代码文件和原来的源文件，将他们一起生成class文件。

简介

本文仅显示部分代码，完整代码参见The one
关于the one 的学习，首先来解读一下官方提供的Readme.txt文件。
官方提供的readme.txt文件中的描述为：ONE是一个机会网络环境模拟器，它提供了一个功能强大的工具，可用于生成移动性跟踪，使用不同的路由协议运行DTN消息传递模拟，以及实时交互式地可视化这两个模拟以及完成后的结果。

这里的DTN表示时延容忍网络（Delay Tolerant networks）在一些特定的环境中，会经常出现网络断开的现象，导致报文在传输过程中不能确保端到端的路径，这类网络被称为时延容忍网络。

所有仿真参数都使用配置文件给出。这些文件是包含键值对的普通文本文件。 大多数变量的语法为：Namespace.key = value。

配置文件

• default_settings.txt
  文件“ default_settings.txt”（如果存在）始终被读取，而另一个
  作为参数给出的配置文件可以定义更多设置，也可以覆盖先前文件中的某些（甚至所有）设置。

  运动模型控制节点

  主要是movement下的内容：
  它们为节点提供坐标，速度和暂停时间。基本的模式有：
• RandomWaypoint.java
  随机航点运动模型，在模拟区域内创建锯齿形路径;当节点使用随机航点运动模型（RandomWaypoint）时，会在模拟区域中为其指定随机坐标。 节点以恒定的速度直接移动到给定的目的地，暂停片刻，然后获取新的目的地。 在整个模拟过程中，这种情况一直持续，并且节点沿这些之字形路径移动.
• mapBasedMovement.java
  基于地图的移动，该模型给出使用SimMap道路的路径;基于地图的运动模型将节点的运动限制为预定义的路径。可以定义不同类型的路径，并且可以为所有节点组定义有效路径。 这样，可以防止例如汽车在室内或人行道上行驶。（MapBasedMovement）首先在两个相邻（即通过路径连接）的地图节点之间分配节点，然后节点开始从相邻的地图节点移动到另一个地图节点。 当节点到达下一个地图节点时，它会随机选择下一个相邻的地图节点，但只有在唯一的选择时才选择它来自的地图节点（即避免返回它的来源）。 节点通过10-100个地图节点移动后，会暂停一会儿，然后再次开始移动。
• ShortestPathMapBasedMovement.java
  基于地图的最短路径的移动，该模型使用Dijkstra算法查找两个随机地图节点与兴趣点之间的最短的路径。基本的基于地图的移动模型;使用Dijkstra最短的pat算法来查找其穿过地图区域的方式。 一旦节点到达其目的地并等待了暂停时间，便会选择一个新的随机地图节点，并使用最短路径（仅可使用有效地图节点才能采用的最短路径）将节点移动到那里。
  对于基于最短路径的运动模型，地图数据还可以包含兴趣点（POI）。 代替为下一个目的地选择任何随机地图节点，可以将运动模型配置为以可配置的概率给出属于某个POI组的POI。 可以有无限数量的POI组，并且所有组可以包含任意数量的POI。 对于所有POI组，所有节点组都可以具有不同的概率。 POI可用于建模例如商店，饭店和旅游景点。
• MapRouteMovement.java
  地图路线移动，使用在一个区域内预定的地图路径。使用这个模型的节点可以在每个录像航点上停下来。使用最短路径算法查找到下一个航点的路线。可以有不同类型的路线。基于路线的运动模型（MapRouteMovement）可用于为遵循某些路线的节点建模，例如 巴士或电车线。 只需定义路径上的站点，然后使用该路径的节点将使用最短路径从站点移到站点，然后在配置的时间内在站点上停止。
  所有运动模型还可以确定节点何时处于活动状态（运动并且可以连接至该节点），以及何时不处于活动状态。 对于所有模型，除了外部运动之外，都可以指定多个模拟时间间隔，并且该组中的节点仅在这些时间段内处于活动状态。
• ExternalMovement.java
  使用外部运动数据（ExternalMovement）的实验运动模型从文件中读取带有时间戳的节点位置，并相应地在仿真中移动节点。 有关格式的详细信息，请参见输入包中的ExternalMovementReader类的javadocs。 工具箱文件夹中包含适用于TRANSIMS数据的实验性转换条（transimsParser.pl）。
• movementModel
  使用“ movementModel”设置为每个节点组定义要使用的运动模型。 设置的值必须是来自运动包的有效运动模型类名称。 所有运动模型共有的设置在MovementModel类中读取，运动模型特定的设置在相应类中读取。 有关详细信息，请参见javadoc文档中的示例配置文件。

  消息路由

  • MessageRouter
    消息路由器的超类，这个类规定了一些通用的设置
  • 消息缓冲区的设置 bufferSize
  • 消息的TTL设置 msgTtl
  • 消息的队列模型设置 sendQueue (主要提供了两个模型，参数值设置是通过设置数字来表示的 )
    • 1 RANDOM 设置，消息的顺序在每一个时间点是随机的
    • 2 FIFO 设置 ，最后收到的消息最后发送
      • 当被请求开始传输数据的时候的返回值
      • RCV_OK（0）表示主机开始接收消息，并且开始传输消息，小于0 表示现在不接收这类特定消息 大于0 表示主机现在不能接收任何消息
      • TRY_LATER_BUSY 1 接收器繁忙的返回值
      • DENIED_OLD -1 接收到已经接收过的消息的返回值
      • DENIED_NO_SPACE -2 接收返回值，因为缓冲区中没有足够的空间用于消息
      • DENIED_TTL = -3 接收TTL已过期的消息的返回值
      • DENIED_LOW_RESOURCES = -4 接收节点的返回值（某些资源不足）
      • DENIED_UNSPECIFIED = -99 接收返回值，原因不明
      • MAX_TTL_VALUE = 35791394 最大的TTL值
        消息缓冲队列分为 message buffer 以及 incoming messages buffer
  • ActiveRouter
    Active routers的超类（正在活动-使用的路由器的超类？）包含传输方式以及监听发送链接

• EpidemicRouter
  泛洪消息路由器，丢弃最老的消息，一次只能传输单个消息

• 相关工具类以及接口

• /core/MessageListener 消息监听器
  用于监听主机之间消息的传输

• 数据格式的输入

  所有基于地图的模型都使用以“Well Known Text”（WKT）格式的子集格式化的文件来获取输入数据。
  • 解析器支持WKT文件的LINESTRING和MULTILINESTRIN伪指令，用于映射路径数据。（MULTI）LINESTRING中的相邻节点被视为形成路径，如果某些线包含一些具有完全相同坐标的顶点，则路径将从这些位置连接起来（这是创建相交的方式）。
  • 对于点数据（例如用于POI），还支持POINT指令。
  • WKT files can be edited and generated from real world map data using any suitable Geographic Information System (GIS) program.
  • The map data included in the simulator distribution was converted and edited using the free, Java based OpenJUMP GIS program.
  • 不同地图类型的数据被存储在不同的文件中
  • 一个WKT文件可以包含多个路由，并且按照在文件中出现的顺序将它们分配给节点。

  • 实验过程

    现在很明显，我们要使用的是ExternalMovement.java这一个文件。
    下面来分析一下这一个文件的作用是什么。
    从这个java文件的结构上来看，这个文件属于一个实体类。
    可以初始化一个有着时间-位置元组的运动模型。

    文件的组成

    文件的第一行应该是offset 头，目前的z轴是可以忽略的，可以在文件中出现。
    minTime maxTime minX maxX minY maxY minZ maxZ

下面几行的语法为：
time id xPos yPos

所有行都必须按时间排序。 整个文件的采样间隔（两个时间实例之间的时间差）必须相同。

一些小的细节(一) tookit的使用

• 当你想要将自己的数据喂给模拟器的时候，如果你需要将你整理好的数据格式 使用tookit中的pl工具进行转化。
  pl工具是用Perl脚本语言进行编写的，如果自己的电脑上没有安装perl工具，就 需要安装perl。运行perl -v 检查自己的工具是不是已经安装成功。
  接下来我在去运行 pl程序。
  我这里要用到的是transimsParser.pl 这个。在运行这个程序的时候出现了两个错误：
  • 第一个是 /usr/local/bin/perl: bad interpreter: No such file or directory
    经过对perl语言的了解，代码中 /usr/local/bin/perl 是 perl 解释器的路径。
    liunx下一般我们的解释路径有两种 格式 一种是 /usr/bin/perl,另一种是/usr/local/bin/perl。可以通过查看并修改脚本，尝试一下
  • 第二个是 Can’t locate Common.pm in @INC (you may need to install the Common module)
    因为这个程序不是我写的，从这个日志上我们可以看出，脚本是因为无法定位到Common.pm模块导致的。第一次接触perl脚本，我就查找了一些安装扩展库的一些方法，但是最终没有找到common这个模块，具体应该安装哪一个。
    对程序分析后，发现这个Common.pm这个是软件设计者自己写的。那么我就将这个模块所在的文件夹，全部用作库文件。在脚本中添加了一个
    use lib ‘/文件模块所在的文件夹‘；
    然后就解决了这个问题；下面是我的配置：

1
2
3
4
5
6
7

#! /usr/bin/perl
package Toolkit;
# Transims vehicle shapshot file parser
use strict;
use warnings;
use lib '/Users/gorge/Downloads/the-one-master/toolkit';
use Common; # parseArgs and debug methods

实验进度一

经过上面的调试，我们的程序使用测试数据运行已经是没有问题的了！
我们接下来要做的是已经知道船舶的运行轨迹数据，我们要做一个仿真，恢复一下船舶的真实运行情况！
我们所有的船舶的数据是存在在txt文件中的。下面我将详细的记录一下整个实验过程。
下面是我们已经处理过的一部分数据了。这是数据格式，我们要关注的是船泊的编号、我这里使用发送时间、已经船舶的经度纬度。其余的就不在关注 了。

1
2

[10032.0, 2.0, 24567613, '2016-09-17 04:13:07', 30.466565, 122.27363166666666, 0.0, 0.0, 0.0, 0.0]
[10032.0, 2.0, 24567643, '2016-09-17 05:13:07', 30.466556666666666, 122.27364333333334, 0.0, 0.0, 0.0014507762179330167, 0.0]

文件目录

1
2
3
4
5
6
7
8
9
10

//文件读取 获得文件夹的列表 并返回一个list(这个list只包含 文件夹中的名称)
	public static String [] getFilePath(String filepath){
		String res [] = null;
		File file  = new File(filepath);
		//苹果产品 下注意.DS_Store隐藏文件的问题。win下同样也要注意隐藏文件
		if(file.isDirectory()) {
			res = file.list();
		}
		return res;
	}

文件路径

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

//进行文件路径的读取 与拼接这部分主要是排除我们不需要的数据文件 
	/**
	 * 
	 * @param path 这个参数是用来接收所有的读取文件的
	 * @param nouse 这个参数是用来增加所有的不使用的文件
	 */
	public static List<String> getpathList(String [] pa,List<String> nouse){
		List<String> geList = new ArrayList<String>();
		for(int i=0;i<pa.length;i++) {
			if(!nouse.contains(pa[i])&&!pa[i].equals(".DS_Store")) {
				geList.add("/Users/gorge/Desktop/newshipData/"+pa[i]);
			}
		}
		return geList;
	}

原始文件读取并返回List<List>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public List<List<String>> readFILE2(String path) {
		File file = new File(path);
		//
		List<List<String>> allList = new ArrayList<List<String>>();
		BufferedReader reader = null;
		try {
			Reader inputStream = new FileReader(file);
			reader = new BufferedReader(inputStream);
			String line = null;
			while((line = reader.readLine())!=null) {
				String liString [] = line.substring(1, line.lastIndexOf("]")).split(",");
				List<String> list = new ArrayList<String>();
				for(String s:liString) {
					list.add(s);
				}
				allList.add(list);
			}
			return allList;
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}

时间转换

这部分是之前用python写的，对于这部分的理解，可以帮助我们对三分钟的记录进行处理，可以看到我们的dataOrgset的索引为2的位置，已经将原来的秒，转换成了分钟，并且进行了取整。

1
2
3
4
5
6
7
8

#定义一个数据集 用来转换输出格式 更直观的能看到数据
    for j in range(len(dataOrgset)):
        #timeArray1 = time.localtime(float(dataOrgset[j][2]))
        #othertime = time.strftime("%Y-%m-%d %H:%M:%S",timeArray1)
        dataOrgset[j][2]=int(float(dataOrgset[j][2])/60)#发送信号的时间 4
        timeArray2 = time.localtime(float(dataOrgset[j][3]))
        othertime2 = time.strftime("%Y-%m-%d %H:%M:%S",timeArray2)
        dataOrgset[j][3]=othertime2#接收信号的时间 5

下面，我们要思考的是如何将时间设置成每条船每隔3分钟取一个记录。我现在的思考是 先从2016年8月31日的零点开始，获得一个秒的时间。然后转化成分钟，然后每隔3分钟进行累加一次，创建一个时间序列。

1
2
3
4
5

import time,datetime
match_time = '2016-08-31 00:00:00'
ans_time_stamp = time.mktime(time.strptime(match_time, "%Y-%m-%d %H:%M:%S"))
print (int(float(ans_time_stamp)/60));
#结果 24542880

我们就是基于上述结果进行每3分钟累加，创建一个时间序列，一直到10月1日的00点 的分钟数为 24586080
(a = (24587520-24542880)/3) = 14880.0 也就是说每条船至少要有14880.0个时间戳，可能位置为空（这一部分我们先处理好）
我这里打算使用map进行映射！筛选出我们每分钟的数据来

1
2
3
4
5
6
7
8
9

//每三分钟获得一次 从2016年8月31号 (这里初始化一个时间序列)
	public Map<Integer,List<String>> initTime(){
		//开始时间是24542880 结束时间是24587520
		Map<Integer,List<String>> timeMap= new LinkedHashMap<Integer,List<String>>();
		for(int i=24542880;i<=24587520;i+=3) {
			timeMap.put(i, null);
		}
		return timeMap;
	}

经过上述操作，对于每一条船，我们就有了一个全局时间戳的 map。下面我们就要将每条船的信息进行填充。
这部分的处理需要分两种情况：

• 连续性空缺
  连续性空缺的意思是已经存在的船舶的数据的记录，两条记录的时间间隔相差较大，对于这部分的处理
• 非连续性空缺
  有长时间的船舶数据的记录的缺失

这里先简单的测试一下结果,版本1.1这部分后期可能还会在优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

//使用时间序列 将已经读取的数据进行 筛选
	public Map<Integer,List<String>> setSingleShip(Map<Integer,List<String>> timeMap,List<List<String>> file1){
		for(int i=0;i<file1.size();i++) {
			String id  = file1.get(i).get(0);
			String curtime = file1.get(i).get(2);
			String lon = file1.get(i).get(5); 
			String lat = file1.get(i).get(4);
			String  xyString [] = millerToXY(Double.parseDouble(lon), Double.parseDouble(lat));
			/**下面就要处理一下时间的问题（下面是一个初步的设置 位置就选3分钟间隔内的任意一个）（因为map中的时间是按照时间序列排列的
			文件中的时间也是按照时间序列排列的，我们就通过遍历文件序列，去找一个map的键）**/
			//先找一个时间的差值
			int  Icurtime  = Integer.parseInt(curtime);
			int diftime =  Icurtime- 24542880;
			List<String> line = new LinkedList<String>();
			if(diftime%3==0) {
				if(timeMap.get(Icurtime).isEmpty()) {
					line.add(id);
					line.add(xyString[0]);
					line.add(xyString[1]);
					timeMap.replace(Icurtime, line);
				}else {
					continue;
				}
			}else {
				int Tkey =Icurtime-diftime%3;
				if(timeMap.get(Tkey).isEmpty()) {
					line.add(id);
					line.add(xyString[0]);
					line.add(xyString[1]);
					timeMap.replace(Tkey, line);
				}else {
					continue;
				}
			}
		}
		return timeMap;
	}

部分代码重新更新一次（这样计算出来的速度是船泊正常速度的2-3倍）

这里的原因，应该是我在进行数据处理的时候，对于每三钟取一次数据，当目标不为空的时候，我直接跳过了，而没有用新的数据进行更新。所以可能存在大部分的轨迹数据，是

坐标转换

经纬度转笛卡尔坐标系 ，地球是一个球形，我们要将地图上的数据，在平面坐标系上运行，则必须进行这个过程。（这个过程中，因为转化完的数据过大，我做了一个数据的放缩，）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

/**
		 * 
		 * @param lon 经度
		 * @param lat 纬度
		 * @return 这里做一个经纬度转笛卡尔乘积的转换函数
		 */
	public static String [] millerToXY(double lon,double lat) {
		String [] xy_coordinate = new String [2];
		//地球周长
		double L = 6381372*Math.PI*2;
		//将平面展开，将周长视为X轴
		double W = L;
		//Y轴约等于周长一般
		double H = L/2;
		double mill =2.3;              //米勒投影中的一个常数，范围大约在正负2.3之间
		double x = lon*Math.PI/180;    //将经度从度数转换为弧度
	    double y = lat*Math.PI/180;    //将纬度从度数转换为弧度 
	     y = 1.25*Math.log(Math.tan(0.25*Math.PI+0.4*y));  //这里是米勒投影的转换 
	     //这里将弧度转为实际距离 ，转换结果的单位是公里
	     x = (W/2)+(W/(2*Math.PI))*x;
	     y = (H/2)-(H/(2*mill))*y;
	     xy_coordinate [0]= String.format("%.2f", (x-33700000)/10);
	     xy_coordinate[1] = String.format("%.2f", (y-7600000)/10);
	     return xy_coordinate;
	}

文件输出

这里为了减少对文件的读写操作，选择将文本直接处理成一个字符串进行读写。减少了IO开销。这部分空缺值的处理 后期还会在修改

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

//字符串的拼接
		public static String WriteValue(Map<Integer,List<String>> file) {
			String value = "";
			Set<Integer> key = file.keySet();
			for (Integer k : key) {
				//如果key对应的值为空怎么办？
				value = value+" "+k;
				if(!file.get(k).isEmpty()) {
					LinkedList<String> line = (LinkedList<String>) file.get(k);
					for(int i =0;i<line.size();i++) {
						value = value+" "+line.get(i);
					}
					value+="\n";
				}else {
					value+="\n";
				}
			}
			return value;
		}

写入字符流

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

/由列表写入文件 注意这里写入的是一个字符串
		public static void writerFile(String path,String value) {
			File file = new File(path);
			if(!file.exists()) {
				try {
					file.createNewFile();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					System.out.println("文件创建失败");
				}
			}
			try {
				FileOutputStream output = new FileOutputStream(file);
				OutputStreamWriter osw = new OutputStreamWriter(output,"UTF-8");
				osw.write(value);
				osw.close();
				output.close();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

文件转换主函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

//通过传入文件夹的路径，将数据转化为可以使用的格式
	public static void transDataFormat(String path,String targ) {
		//首先 获取文件列表(传入文件路径)
		String [] filedir=  getFilePath(path);
		//进行文件链路的拼接 这一个集合是排除的集合
		List<String> nouse = new ArrayList<String>();
		//String head = "";
		List<String> filep = getpathList(path,filedir, nouse);
		FileRead fRead  = new FileRead();
		for(int i=0;i<filep.size();i++) {
			String aaa = filep.get(i);
			List<List<String>> file1 = fRead.readFILE2(aaa);
			Map<Integer, List<String>> file2 = setSingleShip(file1);
			String value = WriteValue(file2);
			writerFile(targ+aaa.substring(aaa.lastIndexOf("/")), value);
		}
	}

到此为止，我们已经拥有了一份格式相对完整的数据了。但是这份数据的内容还完整，数据值的缺失问题，我们该怎么解决？
有部分数据是这样的：

1
2
3
4
5
6
7

24575451 11197.0  30.759755  123.775865
24575454
24575457
24575460 11197.0  30.761711666666667  123.776965
24575463
24575466
24575469 11197.0  30.759831666666667  123.77584333333333

还有一部分数据是这样的：

1
2
3
4
5
6
7
8
9
10
11
12

24574605 11197.0  30.6768  123.77771
24574608
24574611
24574614
24574617
24574620
24574623
24574626
24574629
24574632
24574635 11197.0  30.6768  123.77793166666666
24574638

还有一部分数据是这样的：
这部分与上面最大的区别就是连续好几天的位置记录是空缺的。对于这部分数据我们该怎么弄？

1
2
3
4
5
6
7

24569856
24569859
24569862
24569865
24569868
24569871
.....

筛选数据

上面出现的很多空却的位置数据，有很多可能是对我们实验并没有什么帮助的，因此我们要对数据进行筛选，筛选出这些数据中，有船的数据比较多的时间，以及船。

• 初始化一个空的时间键值对，时间序列作为键，船的编号作为值
• 依次迭代每个文件，然后更新值
  • 遍历第一个文件的时候，初始化Map的值，判断该时刻下是否有船的值.这个过程我们可以通过初始化两个map来实现，这两个map的键是同步的，第一个map相当于一个文件，第二个map用来存储这次值的筛选。
  • 每读取一个文件会构造出第一个map，然后根据第一个map更新第二个map。
  • 更新过程可以设置为根据第二个map的键作为第一个map的键，去查找第一个map中，该键下是否存在值。如果存在值，那么我们就将这个船的编号更新到第二个map中。
  • 直到读取完所有的数据，统计每个map的键中对应的值列表,返回第二个更新过了的map。

(….程序已经跑了一下午了…. 奶奶的，心疼我的电脑～～～～)
(六小时later~~~~）
（八小时～～～）

以我的经验来看，程序一直处于这个运行状态，应该是没有问题的。但是我感觉就目前的数据量，似乎～～不应该运行这么久（😂）
不想糟蹋我的电脑了～～扔到服务器上去跑吧！！！
(在服务器上又跑了一天，出现了connection reset by (server_ip_address) port 22 的程序中断～～)
这个原因，不知道是不是程序字符串的存储的原因～～
…..
字符串是一个对象，是在内存中存储的，没有长度限制，只有内存中堆内存满了，才会导致内存溢出，导致程序中断。所以这里我要将数据进行数据分批处理～～～

我打算将这个文件进行拆分进行处理！！
每一个文件夹下面大约100-150个文件～（这个数据量已经降低了很多了，应该没问题了）～当然这里也可以通过设置多个线程同时处理，为了避免不必要的错误。就直接分解文件了。
统计完后，会产生一个中间文件，用来显示每一个时刻，有着船舶记录的数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

/**
	 * 
	 * @param dirpath 数据文件所在的文件夹目录
	 * @return
	 */
	public static Map<Integer, List<String>> FindDay(String dirpath){
		//初始化一个map2 用来存储文件名
		Map<Integer,List<String>> map2 = initTime();
		//首先 获取文件列表(传入文件路径)
		String [] filedir=  getFilePath(dirpath);
		//进行文件链路的拼接
		List<String> nouse = new ArrayList<String>();
		String head = dirpath;
		List<String> filep = getpathList(head,filedir, nouse);
		FileRead fRead  = new FileRead();
		for(int i=0;i<filep.size();i++) {
			System.out.println(filep.get(i));
			List<List<String>> file1 = fRead.readFILE2(filep.get(i));
			Map<Integer, List<String>> map1 = setSingleShip(file1);
			//进行数据的比较
			Set<Integer> key = map2.keySet();
			
			for (Integer k2 : key) {
				List<String> value1 = map1.get(k2);
				//根据m2的键去拿map1的值，如果m1不为空，则说明有位置数据
				if(!value1.isEmpty()) {
					//获得 map2中的值，并更新
				  List<String> value2 = map2.get(k2);
				  System.out.println(value2.isEmpty());
				  value2.add(value1.get(0));
				}
			}
		}
		
		return map2;
	}

函数调用

1
2
3
4
5

System.out.println("test8开始");
Map<Integer, List<String>> file8 = FindDay("./test/202012Single2/test8/");
String value8 = WriteValue(file8);
writerFile("./test/test8.txt", value8);
System.out.println("test8结束");

test.txt的内容为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

24551988 13881.0 10986.0 13528.0 14208.0 13648.0 13940.0
24551991 13881.0 10986.0 13528.0 14208.0 13648.0 13940.0
24551994 13784.0 13881.0 10986.0 13528.0 14208.0 14339.0 13648.0 13940.0
24551997 13950.0 13881.0 10986.0 13528.0 14208.0 13648.0 13940.0
24552000 13950.0 13784.0 13881.0 10986.0 13528.0 14208.0 13648.0 13940.0
24552003 13950.0 11202.0 12681.0 13881.0 10986.0 13528.0 14208.0 13648.0 13940.0
24552006 13950.0 12681.0 13881.0 10986.0 13528.0 14208.0 13648.0 13940.0
24552009 13950.0 12681.0 13881.0 10986.0 13528.0 14208.0 13940.0
24552012 13950.0 12681.0 13881.0 10986.0 13528.0 14208.0 13940.0
24552015 13950.0 12681.0 14014.0 10986.0 13528.0 14208.0 13940.0
24552018 11341.0 13950.0 12681.0 14014.0 10986.0 13528.0 14208.0 9997.0 13940.0
24552021 13950.0 12681.0 14014.0 10986.0 13528.0 14208.0 13940.0
24552024 13950.0 12681.0 14014.0 10986.0 13528.0 14208.0 14339.0 13648.0 13940.0
24552027 13950.0 12681.0 14014.0 10986.0 13528.0 14208.0 13648.0 13940.0
24552030 13950.0 13784.0 12681.0 14014.0 10986.0 13528.0 14208.0 13648.0 13940.0
24552033 13950.0 11202.0 12681.0 14014.0 10986.0 13528.0 14208.0 13648.0

然后我们在对这些时刻进行统计，得到一个汇总表：
对于这部分我的思路是：

• 首先初始化一个时间map<integer,integer>键为时间戳，值为这个时间下，有船在航行的记录数据

1
2
3
4
5
6
7
8
9
10
11
12
13

/**
	 * 这个方法是为了统计使用 参数flag这是为了与第一个方法进行区分
	 * @param flag 方法重载 标志位 true或flase都可
	 * @return
	 */
	public static Map<Integer,Integer> initTime(boolean flag){
		//开始时间是24542880 结束时间是24587520
		Map<Integer,Integer> timeMap= new LinkedHashMap<Integer,Integer>();
		for(int i=24542880;i<=24587520;i+=3) {
			timeMap.put(i, 0);
		}
		return timeMap;
	}

• 读取文件夹列表，找到中间文件进行统计
• 对文件进行读取，为了减少文件的IO操作，我选择将一个文件读取完之后，在从新进行统计，这里我们就要新增加一个函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public List<List<String>> readFILE3(String path) {
		File file = new File(path);
		List<List<String>> allList = new ArrayList<List<String>>();
		BufferedReader reader = null;
		try {
			Reader inputStream = new FileReader(file);
			reader = new BufferedReader(inputStream);
			String line = null;
			while((line = reader.readLine())!=null) {
				String liString [] = line.split(" ");
				List<String> list = new ArrayList<String>();
				for(String s:liString) {
					list.add(s);
				}
				allList.add(list);
			}
			return allList;
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}

• 统计找出主要的活动时间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

/**
	 * 
	 * @param dirpath 数据文件所在的文件夹目录
	 * @return
	 */
	public static Map<Integer, List<String>> FindDay(String dirpath){
		//初始化一个map2 用来存储文件名
		Map<Integer,List<String>> map2 = initTime();
		//首先 获取文件列表(传入文件路径)
		String [] filedir=  getFilePath(dirpath);
		//进行文件链路的拼接
		List<String> nouse = new ArrayList<String>();
		String head = dirpath;
		List<String> filep = getpathList(head,filedir, nouse);
		FileRead fRead  = new FileRead();
		for(int i=0;i<filep.size();i++) {
			System.out.println(filep.get(i));
			List<List<String>> file1 = fRead.readFILE2(filep.get(i));
			Map<Integer, List<String>> map1 = setSingleShip(file1);
			//进行数据的比较
			Set<Integer> key = map2.keySet();
			
			for (Integer k2 : key) {
				List<String> value1 = map1.get(k2);
				//根据m2的键去拿map1的值，如果m1不为空，则说明有位置数据
				if(!value1.isEmpty()) {
					//获得 map2中的值，并更新
				  List<String> value2 = map2.get(k2);
				  System.out.println(value2.isEmpty());
				  value2.add(value1.get(0));
				}
			}
		}
		
		return map2;
	}

//对一个月以来所有船的活动时间进行一个统计找出，主要的活动时间
	public static Map<Integer,Integer> getMainTime(String path) {
		//首先要初始化一个时间
		Map<Integer,Integer> timeMap = initTime(true);
		//文件夹列表
		//首先 获取文件列表(传入文件路径)
		String [] filedir=  getFilePath(path);
		//进行文件路径的拼接
		//进行文件链路的拼接
		List<String> nouse = new ArrayList<String>();
		String head = path;
		List<String> filep = getpathList(head,filedir, nouse);
		//文件读取
		FileRead fRead  = new FileRead();
		for(int i=0;i<filep.size();i++) {
			List<List<String>> fi = fRead.readFILE3(filep.get(i));
			for(int j = 0;j<fi.size();j++){
				String k = fi.get(j).get(0);
				int value = fi.get(j).size()-1;
				if(value!=0) {
					System.out.println("va"+value);
				}
				//更新map的值
				int mv =timeMap.get(Integer.parseInt(k));
				timeMap.put(Integer.parseInt(k), value+mv);
			}
		}
		return timeMap;
	}

• 将分钟统计到每一天并进行可视化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

//返回一个字符串数组
	public static String [] pytformat(String path) {
		Map<Integer,Integer> timeMap = getMainTime(path);
		String a = "[";
		String b = "[";
		String [] arr = new String[2];
		
		int vee [] = new int[32];
		//每三分钟执行一次，对60*24取余数就是为了确定天数
		int h = 60*24;
		int fist = 24542880;
		Set<Integer> set = timeMap.keySet();
		for(int k : set) {
		   vee [(k-fist)/h] =  vee [(k-fist)/h]+timeMap.get(k);
		}
		for(int i=0;i<vee.length;i++) {
			a+=(","+i);
			b+=(","+vee[i]);
		}
		
		a+="]";
		b+="]";
		arr[0] =a;
		arr[1] =b;
		return arr;
	}

下面是统计分析的结果，从这个结果可以看出，这一批船的主要活动轨迹时间是9月22号到30号之间。

统计每条船的22-30号活动轨迹的占比

筛选出我们真正要用的船,根据上面的统计，我们可以发现船的记录主要是集中在22-30号之间，接下来我们在对所有的船进行筛选，并统计每条船中22-30号之间的有船的记录，占该船所有记录中的比重。

• 第一次将所有的船的比重做一个统计，可以发现，这批船的数据中，所有的船的占比的分布。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

//文件统计单个船的数据是否所占比例较高  数据格式 10 10032.0 30.21381166666667 123.57897666666667
		public double getSingleShip(String path) {
			File file = new File(path);
			BufferedReader reader = null;
			//创建一个变量用来统计一共含有多少条内容
			double total = 1;
			//创建一个变量用来统计符合我们要统计的内容
			double aim = 0;
			try {
				Reader inputStream = new FileReader(file);
				reader = new BufferedReader(inputStream);
				String line = null;
				
				while((line = reader.readLine())!=null) {
					System.out.println(line);
					String liString [] = line.split(" ");
					if(liString.length>=2) {
						++total;
					}
					int curtime = Integer.parseInt(liString[0]);
					int h = 60*24;
					int fist = 24542880;
				     int lower = (curtime-fist)/h;
					if(liString.length==4&&lower<=30&& lower>=22) {
						++aim;
					}
				}
				return aim/total;
				
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			return aim/total;
		}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

//统计出19-30号 十天中，占整个月的比例较大的船,并根据比例尺 统计所占比例的分布
	/**
	 * 
	 * @param path 读取的文件路径
	 * @param jiange 船的占比的间隔
	 */
	public static String getUseShip(String path,int jiange){
		//首先获取文件列表（传入文件路径）
		//使用map进行存储 键是 文件名 值是 这条船19-30号的记录所占的比例
		HashMap<String, Double> map = new HashMap<String, Double>();
		HashMap<Integer, Integer> smap = new HashMap<Integer, Integer>();
		String [] fieldir = getFilePath(path);
		//进行文件路径的链路的拼接 这是一个集合 排除集合
		List<String> nouse = new ArrayList<String>();
		List<String> fielp = getpathList(path, fieldir, nouse);
		for(int i =0;i<fielp.size();i++) {
			String aaa = fielp.get(i);
			FileRead fRead = new FileRead();
			double aim = fRead.getSingleShip(aaa);
			String key = aaa.substring(aaa.lastIndexOf("/"));
			map.put(key, aim);
			int a = (int)(aim*100/jiange);
			if(smap.containsKey(a)) {
				smap.put(a,smap.get(a)+1);
			}else {
				smap.put(a,1);
			}
		}
	 String value = WriteValue(map);
	 writerFile("./test/ttt.txt", value);
	 Set<Integer> keSet = smap.keySet();
	 for(int k : keSet) {
		 System.out.println(k+" "+smap.get(k));
	 }
	 return null;
	}

• 经过上述统计

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

  public static void deleFile(String path) { File file = new File(path+"/ttt.txt"); BufferedReader reader = null; try { Reader inputStream = new FileReader(file); reader = new BufferedReader(inputStream); String line = null; while((line = reader.readLine())!=null) { String liString [] = line.split(" "); System.out.println(liString.length); if(Double.parseDouble(liString[1])<0.80) { File file2 = new File(path+"/updataData"+liString[0]); file2.delete(); System.out.println("删除"+liString[0]); } } } catch (Exception e) { System.out.println(e); } }

我们这里统计了两部分数据，一部分是19-30号所占的比例，另一部分是22-30号所占的比例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# 19-30
0 8
1 1
5 1
7 5
8 11
9 11
10 21
11 11
12 20
13 28
14 25
15 30
16 50
17 89
18 159
19 872

# 22 -30
0 3
4 1
8 1
11 2
12 1
13 5
14 41
15 302
16 339
17 96
18 36
19 45

• 将筛选完的船只截取22 -30 号的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public List<List<String>> readFILE4(String path) {
			File file = new File(path);
			List<List<String>> allList = new ArrayList<List<String>>();
			BufferedReader reader = null;
			try {
				Reader inputStream = new FileReader(file);
				reader = new BufferedReader(inputStream);
				String line = null;
				while((line = reader.readLine())!=null) {
					System.out.println(line);
					String liString [] = line.split(" ");
					System.out.println(liString.length);
					List<String> list = new ArrayList<String>();
						int curtime = Integer.parseInt(liString[0]);
						int h = 60*24;
						int fist = 24542880;
					     int lower = (curtime-fist)/h;
						if(lower<=30&& lower>=22) {
							for(String s:liString) {
								list.add(s);
						}
					}
					allList.add(list);
				}
				return allList;
				
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			return null;
		}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

//将比例占比比较大的船的22-30号这几天的数据进行转存
	public static void subData(String path,String target) {
		//首先 获取文件列表(传入文件路径)
	String [] filedir=  getFilePath(path);
	//进行文件链路的拼接 这一个集合是排除的集合
	List<String> nouse = new ArrayList<String>();
	//String head = "";
	List<String> filep = getpathList(path,filedir, nouse);
	FileRead read  = new FileRead();
	for (int i=0;i<filep.size();i++) {
		String aaa = filep.get(i);
		List<List<String>> file1 = read.readFILE4(aaa);
		String value = WriteValue(file1);
		writerFile(target+aaa.substring(aaa.lastIndexOf("/")), value);
	}
	}

数据缺失值的处理

对于数据的缺失主要分为以下三种情况：
-中间缺失一条（取平均值）
-中间缺失5条以内（根据前面的两条数据的间隔，估计后面的x,y）
-中间缺失5条以上 (缺失五条以上的数据，也就是船在15分钟以上没有发射记录，或者发送了记录，但是发送的记录的条数非常的少，可以默认为这个时间的船舶是静止的）
在实际的数据中，数据的情况比较复杂，因此在程序编写的过程中，需要根据数据的具体情况，对程序进行进一步的调整。因此，这一部分的代码并不是通用的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

public static List<List<String>> insertSinData(List<List<String>> page) {
		//船号  
		String shipn = " ";
	    for(int i =0;i<page.size();i++) {
	    	if(page.get(i).size()==4) {
	    		shipn = page.get(i).get(1);
	    		break;
	    	}
	    }
	    /**
		 * 文件刚开始就有数据的缺失，直接用遇到的第一条完整的数据进行补充
		 */
	    if(page.get(0).size()==1) {
	    	for(int i =0;i<page.size()-1;i++) {
	    		List<String> curline = page.get(i);
	    		if(curline.size() ==4) {
	    			for(int j=i-1;j>=0;j--) {
	    				String x = curline.get(2);
	    				String y = curline.get(3);
	    			  List<String> line = page.get(j);
	    			  line.add(shipn);
	    			  line.add(x);
	    			  line.add(y);
	    			}
	    			break;
	    		}
	    	}
	    }
	
		for(int i =1;i<page.size()-1;i++) {
			List<String> lineList = page.get(i);
			if(lineList.size()==1) {
				
				//中间缺失一条数据  x 与 y就直接取平均值
			     List<String> pro = page.get(i-1);
			     List<String> last = page.get(i+1);
			     //步骤一
				if(pro.size()==4&&last.size()==4) {
					//先将船号添加进去
					lineList.add(shipn);
					String curx = String.format("%.2f",((Double.parseDouble(pro.get(2))+Double.parseDouble(last.get(2)))/2));
					String cury = String.format("%.2f",(Double.parseDouble(pro.get(3))+Double.parseDouble(last.get(3)))/2);
					lineList.add(curx);
					lineList.add(cury);
				}
				//步骤二
				else if(pro.size()==4&&last.size()!=4) {
					List<String> lastline = null;
					int flag = 0;
					for(int z =i;z<page.size()-1;z++) {
			    		List<String> curline = page.get(z);
			    		if(curline.size()!=4) {
			    			flag++;
			    			if(z==page.size()-2) {
			    				lastline = curline;
			    				break;
			    			}
			    		}else {
			    			lastline = curline;
			    			System.out.println(curline);
			    			break;
			    		}
			    	}
					//步骤2.1
					if(flag >5) {
						//如果中间空缺的值多于5个 就默认为这15分钟，船没有移动，或者应为其他原因，
						//船舶停止数据的传输，这段时间，默认为船舶是静止的（中间数据为平均值）
						for(int z = i;z<i+flag;z++) {
							List<String> curline = page.get(z);
							curline.add(shipn);
							String curx ="";
							String cury ="";
							if(pro.size()==4&& lastline.size()==4) {
 							curx = String.format("%.2f",(Double.parseDouble(pro.get(2))+(Double.parseDouble(lastline.get(2))))/2);
 							cury = String.format("%.2f",(Double.parseDouble(pro.get(3))+(Double.parseDouble(lastline.get(3))))/2);
							}else {
								curx = pro.get(2);
								cury = pro.get(3);
							}
							 curline.add(curx);
							 curline.add(cury);
						}
					}
					//步骤2.2
					else {
						for(int z = i;z<i+flag;z++) {
							List<String> curline = page.get(z);
							curline.add(shipn);
							List<String> protwo = null;
							List<String> proOne = null;
							if(i==1) {
								proOne = page.get(z-1);
								protwo = proOne;
							}else {
								 protwo = page.get(z-2);
								 proOne = page.get(z-1);
							}
							System.out.println(proOne);
							System.out.println(protwo);
							double x = Double.parseDouble(proOne.get(2))+(Double.parseDouble(proOne.get(2))-Double.parseDouble(protwo.get(2)));
							double y = Double.parseDouble(proOne.get(3))+(Double.parseDouble(proOne.get(3))-Double.parseDouble(protwo.get(3)));
							if(Math.abs(x)<=10&&Math.abs(y)<=10) {
								String curx = String.format("%.2f",(Double.parseDouble(pro.get(2))+(Double.parseDouble(lastline.get(2))))/2);
	 							String cury = String.format("%.2f",(Double.parseDouble(pro.get(3))+(Double.parseDouble(lastline.get(3))))/2);
							    curline.add(curx);
							    curline.add(cury);
							}else {
 							String curx = String.format("%.2f",x);
 							String cury = String.format("%.2f",y);
						    curline.add(curx);
						    curline.add(cury);
						}
						}
					}
				}						
			}
		}
	    return page;
	}

控制程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17