Java集合---Arrays类源码解析

一、Arrays.sort()数组排序

Java Arrays中提供了对所有类型的排序。其中主要分为Primitive(8种基本类型)和Object两大类。

  基本类型:采用调优的快速排序;

  对象类型:采用改进的归并排序。

 

1、对于基本类型源码分析如下(以int[]为例):

  Java对Primitive(int,float等原型数据)数组采用快速排序,对Object对象数组采用归并排序。对这一区别,sun在<<The Java Tutorial>>中做出的解释如下:

  The sort operation uses a slightly optimized merge sort algorithm that is fast and stable:

  * Fast: It is guaranteed to run in n log(n) time and runs substantially faster on nearly sorted lists. Empirical tests showed it to be as fast as a highly optimized quicksort. A quicksort is generally considered to be faster than a merge sort but isn't stable and doesn't guarantee n log(n) performance.

  * Stable: It doesn't reorder equal elements. This is important if you sort the same list repeatedly on different attributes. If a user of a mail program sorts the inbox by mailing date and then sorts it by sender, the user naturally expects that the now-contiguous list of messages from a given sender will (still) be sorted by mailing date. This is guaranteed only if the second sort was stable.

  也就是说,优化的归并排序既快速(nlog(n))又稳定。

  对于对象的排序,稳定性很重要。比如成绩单,一开始可能是按人员的学号顺序排好了的,现在让我们用成绩排,那么你应该保证,本来张三在李四前面,即使他们成绩相同,张三不能跑到李四的后面去。

  而快速排序是不稳定的,而且最坏情况下的时间复杂度是O(n^2)。

  另外,对象数组中保存的只是对象的引用,这样多次移位并不会造成额外的开销,但是,对象数组对比较次数一般比较敏感,有可能对象的比较比单纯数的比较开销大很多。归并排序在这方面比快速排序做得更好,这也是选择它作为对象排序的一个重要原因之一。

  排序优化:实现中快排和归并都采用递归方式,而在递归的底层,也就是待排序的数组长度小于7时,直接使用冒泡排序,而不再递归下去。

  分析:长度为6的数组冒泡排序总比较次数最多也就1+2+3+4+5+6=21次,最好情况下只有6次比较。而快排或归并涉及到递归调用等的开销,其时间效率在n较小时劣势就凸显了,因此这里采用了冒泡排序,这也是对快速排序极重要的优化。

 

  源码中的快速排序,主要做了以下几个方面的优化:

  1)当待排序的数组中的元素个数较少时,源码中的阀值为7,采用的是插入排序。尽管插入排序的时间复杂度为0(n^2),但是当数组元素较少时,插入排序优于快速排序,因为这时快速排序的递归操作影响性能。

  2)较好的选择了划分元(基准元素)。能够将数组分成大致两个相等的部分,避免出现最坏的情况。例如当数组有序的的情况下,选择第一个元素作为划分元,将使得算法的时间复杂度达到O(n^2).

  源码中选择划分元的方法:

    当数组大小为 size=7 时 ,取数组中间元素作为划分元。int n=m>>1;(此方法值得借鉴)

    当数组大小 7<size<=40时,取首、中、末三个元素中间大小的元素作为划分元。

    当数组大小 size>40 时 ,从待排数组中较均匀的选择9个元素,选出一个伪中数做为划分元。

  3)根据划分元 v ,形成不变式 v* (<v)* (>v)* v*

  普通的快速排序算法,经过一次划分后,将划分元排到素组较中间的位置,左边的元素小于划分元,右边的元素大于划分元,而没有将与划分元相等的元素放在其附近,这一点,在Arrays.sort()中得到了较大的优化。

  举例:15、93、15、41、6、15、22、7、15、20

  因  7<size<=40,所以在15、6、和20 中选择v = 15 作为划分元。

  经过一次换分后: 15、15、7、6、41、20、22、93、15、15. 与划分元相等的元素都移到了素组的两边。

  接下来将与划分元相等的元素移到数组中间来,形成:7、6、15、15、15、15、41、20、22、93.

  最后递归对两个区间进行排序[7、6]和[41、20、22、93].

 

  部分源代码(一)如下:

1 package com.util;2 3 public class ArraysPrimitive {4     private ArraysPrimitive() {}5 6     /**7     * 对指定的 int 型数组按数字升序进行排序。8      */9     public static void sort(int[] a) {10         sort1(a, 0, a.length);11    }12     13     /**14     * 对指定 int 型数组的指定范围按数字升序进行排序。15      */16     public static void sort(int[] a, int fromIndex, int toIndex) {17        rangeCheck(a.length, fromIndex, toIndex);18         sort1(a, fromIndex, toIndex - fromIndex);19    }20 21     private static void sort1(int x[], int off, int len) {22         /*23         * 当待排序的数组中的元素个数小于 7 时,采用插入排序 。24         * 25         * 尽管插入排序的时间复杂度为O(n^2),但是当数组元素较少时, 插入排序优于快速排序,因为这时快速排序的递归操作影响性能。26          */27         if (len < 7) {28             for (int i = off; i < len + off; i++)29                 for (int j = i; j > off && x[j - 1] > x[j]; j--)30                     swap(x, j, j - 1);31             return;32        }33         /*34         * 当待排序的数组中的元素个数大于 或等于7 时,采用快速排序 。35         * 36         * Choose a partition element, v37         * 选取一个划分元,V38         * 39         * 较好的选择了划分元(基准元素)。能够将数组分成大致两个相等的部分,避免出现最坏的情况。例如当数组有序的的情况下,40         * 选择第一个元素作为划分元,将使得算法的时间复杂度达到O(n^2).41          */42         // 当数组大小为size=7时 ,取数组中间元素作为划分元。43         int m = off + (len >> 1);44         // 当数组大小 7<size<=40时,取首、中、末 三个元素中间大小的元素作为划分元。45         if (len > 7) {46             int l = off;47             int n = off + len - 1;48             /*49             * 当数组大小  size>40 时 ,从待排数组中较均匀的选择9个元素,50             * 选出一个伪中数做为划分元。51              */52             if (len > 40) {53                 int s = len / 8;54                 l = med3(x, l, l + s, l + 2 * s);55                 m = med3(x, m - s, m, m + s);56                 n = med3(x, n - 2 * s, n - s, n);57            }58             // 取出中间大小的元素的位置。59             m = med3(x, l, m, n); // Mid-size, med of 360        }61         62         //得到划分元V63         int v = x[m];64         65         // Establish Invariant: v* (<v)* (>v)* v*66         int a = off, b = a, c = off + len - 1, d = c;67         while (true) {68             while (b <= c && x[b] <= v) {69                 if (x[b] == v)70                     swap(x, a++, b);71                 b++;72            }73             while (c >= b && x[c] >= v) {74                 if (x[c] == v)75                     swap(x, c, d--);76                 c--;77            }78             if (b > c)79                 break;80             swap(x, b++, c--);81        }82         // Swap partition elements back to middle83         int s, n = off + len;84         s = Math.min(a - off, b - a);85         vecswap(x, off, b - s, s);86         s = Math.min(d - c, n - d - 1);87         vecswap(x, b, n - s, s);88         // Recursively sort non-partition-elements89         if ((s = b - a) > 1)90            sort1(x, off, s);91         if ((s = d - c) > 1)92             sort1(x, n - s, s);93    }94     95     /**96     * Swaps x[a] with x[b].97      */98     private static void swap(int x[], int a, int b) {99         int t = x[a];
100         x[a] = x[b];
101         x[b] = t;
102    }
103     
104     /**
105     * Swaps x[a .. (a+n-1)] with x[b .. (b+n-1)].
106      */
107     private static void vecswap(int x[], int a, int b, int n) {
108     for (int i=0; i<n; i++, a++, b++)
109        swap(x, a, b);
110    }
111     
112     /**
113     * Returns the index of the median of the three indexed integers.
114      */
115     private static int med3(int x[], int a, int b, int c) {
116         return (x[a] < x[b] ? (x[b] < x[c] ? b : x[a] < x[c] ? c : a)
117                 : (x[b] > x[c] ? b : x[a] > x[c] ? c : a));
118    }
119 
120     /**
121     * Check that fromIndex and toIndex are in range, and throw an
122     * appropriate exception if they aren't.
123      */
124     private static void rangeCheck(int arrayLen, int fromIndex, int toIndex) {
125         if (fromIndex > toIndex)
126             throw new IllegalArgumentException("fromIndex(" + fromIndex
127                     + ") > toIndex(" + toIndex + ")");
128         if (fromIndex < 0)
129             throw new ArrayIndexOutOfBoundsException(fromIndex);
130         if (toIndex > arrayLen)
131             throw new ArrayIndexOutOfBoundsException(toIndex);
132    }
133 }

测试代码如下:

1 package com.test;2 3 import com.util.ArraysPrimitive;4 5 public class ArraysTest {6     public static void main(String[] args) {7         int [] a={15,93,15,41,6,15,22,7,15,20};8        ArraysPrimitive.sort(a);9         for(int i=0;i<a.length;i++){
10             System.out.print(a[i]+",");
11        }
12         //结果:6,7,15,15,15,15,20,22,41,93,
13    }
14 }

2、对于Object类型源码分析如下:

  部分源代码(二)如下:

1 package com.util;2 3 import java.lang.reflect.Array;4 5 public class ArraysObject {6     private static final int INSERTIONSORT_THRESHOLD = 7;7 8     private ArraysObject() {}9 10     public static void sort(Object[] a) {11         //java.lang.Object.clone(),理解深表复制和浅表复制12         Object[] aux = (Object[]) a.clone();13         mergeSort(aux, a, 0, a.length, 0);14    }15 16     public static void sort(Object[] a, int fromIndex, int toIndex) {17        rangeCheck(a.length, fromIndex, toIndex);18         Object[] aux = copyOfRange(a, fromIndex, toIndex);19         mergeSort(aux, a, fromIndex, toIndex, -fromIndex);20    }21 22     /**23     * Src is the source array that starts at index 0 24     * Dest is the (possibly larger) array destination with a possible offset 25     * low is the index in dest to start sorting 26     * high is the end index in dest to end sorting 27     * off is the offset to generate corresponding low, high in src28      */29     private static void mergeSort(Object[] src, Object[] dest, int low,30             int high, int off) {31         int length = high - low;32 33         // Insertion sort on smallest arrays34         if (length < INSERTIONSORT_THRESHOLD) {35             for (int i = low; i < high; i++)36                 for (int j = i; j > low && 37                         ((Comparable) dest[j - 1]).compareTo(dest[j]) > 0; j--)38                     swap(dest, j, j - 1);39             return;40        }41 42         // Recursively sort halves of dest into src43         int destLow = low;44         int destHigh = high;45         low += off;46         high += off;47         /*48         *  >>>:无符号右移运算符49         *  expression1 >>> expresion2:expression1的各个位向右移expression250         *  指定的位数。右移后左边空出的位数用0来填充。移出右边的位被丢弃。51         *  例如:-14>>>2;  结果为:107374182052          */53         int mid = (low + high) >>> 1;54         mergeSort(dest, src, low, mid, -off);55         mergeSort(dest, src, mid, high, -off);56 57         // If list is already sorted, just copy from src to dest. This is an58         // optimization that results in faster sorts for nearly ordered lists.59         if (((Comparable) src[mid - 1]).compareTo(src[mid]) <= 0) {60            System.arraycopy(src, low, dest, destLow, length);61             return;62        }63 64         // Merge sorted halves (now in src) into dest65         for (int i = destLow, p = low, q = mid; i < destHigh; i++) {66             if (q >= high || p < mid67                     && ((Comparable) src[p]).compareTo(src[q]) <= 0)68                 dest[i] = src[p++];69             else70                 dest[i] = src[q++];71        }72    }73 74     /**75     * Check that fromIndex and toIndex are in range, and throw an appropriate76     * exception if they aren't.77      */78     private static void rangeCheck(int arrayLen, int fromIndex, int toIndex) {79         if (fromIndex > toIndex)80             throw new IllegalArgumentException("fromIndex(" + fromIndex81                     + ") > toIndex(" + toIndex + ")");82         if (fromIndex < 0)83             throw new ArrayIndexOutOfBoundsException(fromIndex);84         if (toIndex > arrayLen)85             throw new ArrayIndexOutOfBoundsException(toIndex);86    }87 88     public static <T> T[] copyOfRange(T[] original, int from, int to) {89         return copyOfRange(original, from, to, (Class<T[]>) original.getClass());90    }91 92     public static <T, U> T[] copyOfRange(U[] original, int from, int to,93             Class<? extends T[]> newType) {94         int newLength = to - from;95         if (newLength < 0)96             throw new IllegalArgumentException(from + " > " + to);97         T[] copy = ((Object) newType == (Object) Object[].class)98                 ? (T[]) new Object[newLength]99                : (T[]) Array.newInstance(newType.getComponentType(), newLength);
100         System.arraycopy(original, from, copy, 0,
101                 Math.min(original.length - from, newLength));
102         return copy;
103    }
104 
105     /**
106     * Swaps x[a] with x[b].
107      */
108     private static void swap(Object[] x, int a, int b) {
109         Object t = x[a];
110         x[a] = x[b];
111         x[b] = t;
112    }
113 }

测试代码如下:

1 package com.test;2 3 import com.util.ArraysObject;4 5 public class ArraysObjectSortTest {6     public static void main(String[] args) {7         Student stu1=new Student(1001,100.0F);8         Student stu2=new Student(1002,90.0F);9         Student stu3=new Student(1003,90.0F);
10         Student stu4=new Student(1004,95.0F);
11         Student[] stus={stu1,stu2,stu3,stu4};
12         //Arrays.sort(stus);
13        ArraysObject.sort(stus);
14         for(int i=0;i<stus.length;i++){
15             System.out.println(stus[i].getId()+" : "+stus[i].getScore());
16        }
17         /* 1002 : 90.0
18         * 1003 : 90.0
19         * 1004 : 95.0
20         * 1001 : 100.0
21          */
22    }
23 }
24 class Student implements Comparable<Student>{
25     private int id;  //学号
26     private float score;  //成绩
27     public Student(){}
28     public Student(int id,float score){
29         this.id=id;
30         this.score=score;
31    }
32    @Override
33     public int compareTo(Student s) {
34         return (int)(this.score-s.getScore());
35    }
36     public int getId() {
37         return id;
38    }
39     public void setId(int id) {
40         this.id = id;
41    }
42     public float getScore() {
43         return score;
44    }
45     public void setScore(float score) {
46         this.score = score;
47    }
48 }

辅助理解代码:

1 package com.lang;2 3 public final class System {4     //System 类不能被实例化。 5     private System() {}6     //在 System 类提供的设施中,有标准输入、标准输出和错误输出流;对外部定义的属性7     //和环境变量的访问;加载文件和库的方法;还有快速复制数组的一部分的实用方法。8     /**9     * src and dest都必须是同类型或者可以进行转换类型的数组.
10     * @param      src      the source array.
11     * @param      srcPos   starting position in the source array.
12     * @param      dest     the destination array.
13     * @param      destPos  starting position in the destination data.
14     * @param      length   the number of array elements to be copied.
15      */
16     public static native void arraycopy(Object src, int srcPos, Object dest,
17             int destPos, int length);
18 }1 package com.lang.reflect;2 3 public final class Array {4     private Array() {}5     6     //创建一个具有指定的组件类型和维度的新数组。7     public static Object newInstance(Class<?> componentType, int length)8             throws NegativeArraySizeException {9         return newArray(componentType, length);
10    }
11 
12     private static native Object newArray(Class componentType, int length)
13             throws NegativeArraySizeException;
14 }

二、Arrays.asList

慎用ArrayList的contains方法,使用HashSet的contains方法代替

在启动一个应用的时候,发现其中有一处数据加载要数分钟,刚开始以为是需要load的数据比较多的缘故,查了一下数据库有6条左右,但是单独写了一个数据读取的方法,将这6万多条全部读过来,却只需要不到10秒钟,就觉得这里面肯定有问题,于是仔细看其中的逻辑,其中有一段数据去重的逻辑,就是记录中存在某几个字段相同的,就认为是重复数据,就需要将重复数据给过滤掉。这里就用到了一个List来存放这几个字段所组成的主键,如果发现相同的就不处理,代码无非就是下面这样:

 

1 List<string> uniqueKeyList = new ArrayList<string>();  
2 //......  
3 if (uniqueKeyList.contains(uniqueKey)) {  
4                    continue;  }

 

根据键去查找是不是已经存在了,来判断是否重复数据。经过分析,这一块耗费了非常多的时候,于是就去查看ArrayList的contains方法的源码,发现其最终会调用他本身的indexOf方法:

 

7public int indexOf(Object elem) {  
8    if (elem == null) {  
9        for (int i = 0; i < size; i++)  
10        if (elementData[i]==null)  
11            return i;  
12    } else {  
13        for (int i = 0; i < size; i++)  
14        if (elem.equals(elementData[i]))  
15            return i;  
16    }  
17    return -1;  
18    }  

 

原来在这里他做的是遍历整个list进行查找,最多可能对一个键的查找会达到6万多次,也就是会扫描整个List,验怪会这么慢了。

于是将原来的List替换为Set:

 

Set<string> uniqueKeySet = new HashSet<string>();  
//......  
if (uniqueKeySet.contains(uniqueKey)) {  continue;  
} 

 

速度一下就上去了,在去重这一块最多花费了一秒钟,为什么HashSet的速度一下就上去了,那是因为其内部使用的是Hashtable,这是HashSet的contains的源码:

 

public boolean contains(Object o) {  return map.containsKey(o);  
} 

 

关于UnsupportedOperationException异常

     在使用Arrays.asList()后调用add,remove这些method时出现java.lang.UnsupportedOperationException异常。这是由于Arrays.asList() 返回java.util.Arrays$ArrayList, 而不是ArrayList。Arrays$ArrayList和ArrayList都是继承AbstractList,remove,add等method在AbstractList中是默认throw UnsupportedOperationException而且不作任何操作。ArrayList override这些method来对list进行操作,但是Arrays$ArrayList没有override remove(),add()等,所以throw UnsupportedOperationException。

 

转载于:https://www.cnblogs.com/ITtangtang/p/3948765.html

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/460117.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

oracle12c多个pdb,ProxmoxVE 之 oracle12C 多CDB和PDB

上面左边是我的个人微信&#xff0c;如需进一步沟通&#xff0c;请加微信。 右边是我的公众号“Openstack私有云”&#xff0c;如有兴趣&#xff0c;请关注。继上次在PVE环境上搭建了oracle12C RAC环境(请参考博文“ProxmoxVE 之 安装oracle12C rac集群”)并且安装使用CDB和PD…

【Pascal's Triangle II 】cpp

题目&#xff1a; Given an index k, return the kth row of the Pascals triangle. For example, given k 3,Return [1,3,3,1]. Note:Could you optimize your algorithm to use only O(k) extra space? 代码&#xff1a; class Solution { public:vector<int> getRow…

【DP】HDU 2189 悼念512汶川大地震遇难同胞——来生一起走

打一个小于150的素数表 为了分成的组的人数不重复用dp[i][j] 表示 i表示i个人 j表示分成的组内的最大素数序号 #include <stdio.h> #include <string.h> #include <stdlib.h> #include <math.h> #include <string> #include <iostream> #…

oracle高资源消耗sql,Oracle高资源消耗SQL语句定位

Oracle SQL语句资源消耗监控最常用的系统视图有v$sql、v$sqlarea、v$sqltext和v$session。本文我们先了解这些视图的作用与区别&#xff0c;然后了解如何定位高资源消耗SQL语句&#xff0c;最后再了解一下各视图字段具体含义。相关系统视图功能与区别v$sql和v$sqlarea基本相同&…

JavaScript动画知多少?

今天&#xff0c;小学生以自己浅薄的见地&#xff0c;在前辈大能的基础上写这篇文章&#xff0c;希望给大家打开一扇窥探JavaScript&#xff08;以下简称JS&#xff09;动画的窗户。 JS如何制造出动画效果&#xff1f; 结合浏览器提供的 setInterval 或 setTimeout API&#xf…

Socket网络编程--简单Web服务器(6)

本来是想实现ssl连接的&#xff0c;但是弄了好久都不成功&#xff0c;就索性不做了&#xff0c;等以后有能力再做了。所以这一小节就是本次的最后一节了。就简单的说几个注意点。 1.加个配置文件 使用单例模式&#xff0c;使用一个类&#xff0c;该类保存一些信息&#xff0c;例…

postgresql调优

http://blog.pgaddict.com/posts/performance-since-postgresql-7-4-to-9-4-pgbench硬件和系统配置操作系统Ubuntu13.04系统位数64CPUIntel(R) Core(TM)2 Duo CPU内存4G硬盘Seagate ST2000DM001-1CH164测试工具PostgreSQL-9.1.11测试工具工具名称pgbench数据量200W&#xff08;…

操作系统--进程状态切换以及cpu调度(转)

http://www.cnblogs.com/coder2012/p/3204730.html 进程的状态转换 进程在运行中不断地改变其运行状态。通常&#xff0c;一个运行进程必须具有以下三种基本状态。 进程状态 执行态run&#xff1a;进程正在使用CPU等待态wait&#xff1a;进程正在等待I/O完成&#xff0c;不在使…

oracle打开当前表的编辑,oracle sqlplus常用命令

Oracle sqlplus 常用命令1、查看当前库的所有数据表&#xff1a;SQL> select TABLE_NAME from all_tables;select * from all_tables;SQL> select table_name from all_tables where table_name like ‘u’; TABLE_NAME———————————————default_auditing_o…

在Exchange 2010中重建Exchange安全组

问题:有时候&#xff0c;重新安装Exchange 2010会corrupt掉Exchange安全组&#xff0c;或者出现重复的组。用户在这种情况下会出现访问被拒的情况。分析:我们可以删掉这些安全组&#xff0c;然后最这些安全组进行重建&#xff1a;当你prepare ad的时候&#xff0c;由于OtherWel…

1023:坑爹的黑店

题目描述 今天小明去了一个风景如画的地方散心&#xff0c;但是自己带的饮料喝完了&#xff0c;小明口渴难耐&#xff0c;见不远处有家小商店&#xff0c;于是跑去买饮料。小明&#xff1a;“我要买饮料&#xff01;”店主&#xff1a;“我们这里有三种饮料&#xff0c;矿泉水1…

php判断电脑浏览器模拟手机访问网页,在PC上测试移动端网站和模拟手机浏览器的5大方法...

查了很多资料&#xff0c;尝试了大部分方法&#xff0c;下面将这一天的努力总结下分享给大家&#xff0c;也让大家免去看那么多文章&#xff0c;以下介绍的方法&#xff0c;都是本人亲自测试成功的方法&#xff0c;测试环境winxp。一、Chrome*浏览器 chrome模拟手机总共有四种方…

带弹出列表的EditText

最近做的一个Andriod里有一个这个要求&#xff0c;一个东西需要输入&#xff0c;但同时可以在列表直接选择。看到这个需求&#xff0c;瞬间想到了QQ的登录界面&#xff0c;那个账号输入的控件正式我所需要的。 这个账号输入框右边有一个按钮&#xff0c;点击可以显示一个下拉列…

SICP第三章题解

目录 SICP第三章题解ex3-17ex3-18ex3-19队列ex3-21ex3-22ex3-24ex3-253.4 并发&#xff1a;时间是一个本质问题ex3-383.4.2 控制并发的机制ex3-39ex3-41ex3-42串行化、序列化ex3-44串行化的实现ex3-47死锁3.5 流ex3-50序列加速器SICP第三章题解 标签&#xff08;空格分隔&#…

linux cp 目录不存在自动创建,linux – 如果不存在,如何cp文件和创建目录?

我想将svn存储库中的修改文件复制到另一个目录,同时保留其目录结构.在阅读awk和xargs manpage之后,我找到了一种方法来获取更改的文件名,如下所示&#xff1a;$svn status -q | awk { print $2 } | xargs -d \\n -I {} cp {} /tmp/xen/但问题是以这种方式不保留目录结构,我想复…

ios 中 KVO

KVO&#xff08;Key value observe&#xff09;键值观察&#xff0c;是ios中的一种核心的概念&#xff0c;简单的理解为当某一个对象A&#xff08;或者多个对象&#xff09;要想监听对象的B的一个或者多个属性发生变化时&#xff0c;就是用这种机制。 KVO的优点 当某个对象有个…

获取win7时区所有信息

打开命令行工具&#xff1a; tzutil /l# 或者输入到文件中tzutil /l > data.txt 1 # -*- utf-8 -*-2 3 """获取win7所有时区信息&#xff0c;并写入到sql语句中4 5 Usage: python data.py -f data.txt -o data.sql6 """7 8 if __name__ &quo…

linux kill命令信号,Linux kill 命令详解

Linux kill 命令很容易让人产生误解&#xff0c;以为它仅仅就是用来杀死进程的。我们来看一下 man page 对它的解释&#xff1a;kill - send a signal to a process.从官方的解释不难看出&#xff0c;kill 是向进程发送信号的命令。当然我们可以向进程发送一个终止运行的信号&a…

VSTO学习笔记(二)Excel对象模型

原文:VSTO学习笔记&#xff08;二&#xff09;Excel对象模型上一次主要学习了VSTO的发展历史及其历代版本的新特性&#xff0c;概述了VSTO对开发人员的帮助和效率提升。从这次开始&#xff0c;将从VSTO 4.0开始&#xff0c;逐一探讨VSTO开发中方方面面&#xff0c;本人接触VSTO…

zen-coding for notepad++,前端最佳手写代码编辑器

zen-Coding是一款快速编写HTML,CSS&#xff08;或其他格式化语言&#xff09;代码的编辑器插件&#xff0c;这个插件可以用缩写方式完成大量重复的编码工作&#xff0c;是web前端从业者的利器。 zen-Coding插件支持多种编辑器&#xff0c;如UltraEdit&#xff0c;Notepad等。 温…