Java on 庞玉栋个人博客

Java两种方法实现简单爬虫

Thu, 28 Nov 2019 16:21:04 +0800

第一种：利用HttpClient和Jsoup爬取网站数据

package com.company;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
public class Main {
public static void main (String[] args) throws Exception {
 // 创建默认的客户端实例
 CloseableHttpClient httpClient = HttpClients.createDefault();

 // 创建get请求实例
 HttpGet httpget = new HttpGet("/");

 System.out.println("executing request " + httpget.getURI());
 String content = "";

 try {
 // 客户端执行get请求返回响应
 CloseableHttpResponse response = httpClient.execute(httpget);

 // 服务器响应状态行
 System.out.println(response.getStatusLine().toString());

 Header[] heads = response.getAllHeaders();
 HttpEntity entity = response.getEntity();

 if (entity != null) {
 content += EntityUtils.toString(entity, "utf-8");
 EntityUtils.consume(entity);// 关闭内容流
 }

 System.out.println(content);
 System.out.println(response.getHeaders("Content-Type"));
 // 打印所有响应头

 for(Header h:heads){
 System.out.println(h.getName()+":"+h.getValue());
 }
 } finally {
 httpClient.close();
 }
}

}

Hadoop 当中 Datanode节点不启动的解决办法

Sat, 06 Jul 2019 08:35:41 +0800

2019-03-28 08:31:49,347 WARN org.apache.hadoop.hdfs.server.common.Storage: Failed to add storage directory [DISK]file:/opt/hadoop-repo/data/
java.io.IOException: Incompatible clusterIDs in /opt/hadoop-repo/data: namenode clusterID = CID-50b8afea-9e44-4363-970d-4a40917d968a; datanode clusterID = CID-865e7596-297e-4d6a-a997-afec3be712e9
	at org.apache.hadoop.hdfs.server.datanode.DataStorage.doTransition(DataStorage.java:777)
	at org.apache.hadoop.hdfs.server.datanode.DataStorage.loadStorageDirectory(DataStorage.java:300)
	at org.apache.hadoop.hdfs.server.datanode.DataStorage.loadDataStorage(DataStorage.java:416)
	at org.apache.hadoop.hdfs.server.datanode.DataStorage.addStorageLocations(DataStorage.java:395)
	at org.apache.hadoop.hdfs.server.datanode.DataStorage.recoverTransitionRead(DataStorage.java:573)
	at org.apache.hadoop.hdfs.server.datanode.DataNode.initStorage(DataNode.java:1393)
	at org.apache.hadoop.hdfs.server.datanode.DataNode.initBlockPool(DataNode.java:1358)
	at org.apache.hadoop.hdfs.server.datanode.BPOfferService.verifyAndSetNamespaceInfo(BPOfferService.java:313)
	at org.apache.hadoop.hdfs.server.datanode.BPServiceActor.connectToNNAndHandshake(BPServiceActor.java:216)
	at org.apache.hadoop.hdfs.server.datanode.BPServiceActor.run(BPServiceActor.java:637)
	at java.lang.Thread.run(Thread.java:748)

直接删除数据节点DataNode的current文件夹，即可启动

Java实现冒泡排序

Sat, 16 Feb 2019 10:38:10 +0800

冒泡排序：

利用冒泡排序对数组进行排序

基本概念：

依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。

代码如下：

package 冒泡排序;
import java.util.Arrays;
public class BubbleSort1 {
public static void BubbleSort(int[] arr) {
boolean flag = true;
while(flag){
int temp;//定义一个临时变量
for(int i=0;i<arr.length-1;i++){//冒泡趟数，n-1趟
for(int j=0;j<arr.length-i-1;j++){
if(arr[j+1]<arr[j]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
flag = true;
}
}
if(!flag){
break;//若果没有发生交换，则退出循环
}
}
}
}
public static void main(String[] args) {
int arr[] = new int[]{1,6,2,2,5};
BubbleSort.BubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
}

人生苦短,我用python “Life is short. You need Python.”

Fri, 09 Nov 2018 08:22:51 +0800

Python 在约 40 年前出现，现在已经有数以千计基于这项技术的网站和软件项目。Python 因其独有的特点从众多开发语言中脱颖而出，深受世界各地的开发者喜爱。

正文共：4565 字

预计阅读时间：12 分钟

人生苦短，我用 Python ，不知道从什么时候开始，这句话开始流行。

人们可能会说， 2017 年是 Python 辉煌的一年。毕竟在这一年中，Python 的增长速度令人惊艳。

主要编程语言的增长趋势，图片来自 Stack Overflow

在GitHub 2017年度报告中，Python 超越 Java 成第二受欢迎语言。在 ranked.com 的排名中，Python 是 2017 年最受欢迎人工智能编程语言（第二是 C++，R 并未上榜）。

根据 Stack Overflow 流量统计，2017 年 6 月，Python 第一次成为高收入国家 Stack Overflow 访问量最大的标签。

在 TIOBE 2018 年 4 月编程语言排行榜前 20 名中，Python 已跃居到第四位，前三分别为为 Java ，C、C++。

大数据行业就业指南

Mon, 01 Oct 2018 09:00:25 +0800

大数据行业就业指南

大数据开发工程师/大数据运维/Hadoop开发：

熟悉Hadoop生态圈（ MapReduce，hdfs，Hive，Spark等相关组件），liunx（shell脚本）相关技术以及对源码有深入认识，熟悉mysql数据库等，掌握JAVA语言或者python语言（有的公司要求掌握Scala语言，流式处理框架使用经验，熟悉Tableau报表设计

数据采集工程师/网络爬虫工程师/反爬虫工程师:

熟悉Selenium, phantomjs, scrapy等自动化测试工具，以及爬虫框架，精通Java/Objective-C/python等至少一种语言，了解各种前端技术，包括XHTML/XML/CSS/JavaScript/AJAX等；熟悉正则表达式和XPATH，能够从结构化或非结构化数据中获取信息；熟悉DDMS、Instruments，Charles，Fildder等抓包工具;，熟悉网络编程，对TCP/IP有深入理解，精通MySQL或PostgreSQL；熟悉Redis或MongoDB；了解linux优先

大数据分析工程师/统计建模师/数据管理/数据统计

熟悉R/Spark/Python或C/C++等至少一个常用语言；以机器学习、深度学习、复杂网络、自然语言处理等其中一种或几种模型见长；对建模技术的前沿探索有热情，优秀的学习能力和逻辑思考能力；对风险管理、用户生命周期管理、或不同垂直领域有深入研究，对各式海量数据分析与挖掘有强烈兴趣。具备ETL数据处理能力，有经验者优先，优秀的逻辑思维能力，和数据敏感度，可从海量数据中日趋分析并反推业务逻辑，优化核心业务流程；

数据可视化工程师：

. 理解W3C标准与ES规范，熟悉Web语义化，掌握盒模型、常用布局以及浏览器兼容性；熟练掌握各项Web前端技术 (HTML/CSS/Javascript) ，了解svg，canvas，webgl技术；熟练掌握JET Charts/ECharts/HighCharts/D3.js/Three.js等图形库熟练使用可视化BI工具及前端工具，具有计算机图形学理论基础，熟悉数据可视化相关基础算法；熟悉 HTTP 协议及缓存，了解基本的浏览器渲染及网络传输过程，掌握Java/python等一门语言，有前端开发经验/大规模数据存储，处理经验者优先

如何从命令提示符运行Java程序

Sat, 28 Jul 2018 13:51:21 +0800

Java是最常用的编程语言之一。它也是一个IDE密集型编程语言，与Eclipse紧密集成。如果您刚开始学习Java，下面是帮助您从命令提示符开始运行Java应用程序（在Windows中）的基本指南。

安装Java开发工具包（JDK）

在您的计算机上运行Java程序之前，您需要安装一个Java编译器。它附带了Java开发工具包或JDK。它是Java在任何平台上开发的基本工具。JDK与Java运行时环境(或JRE)不一样，如果您在您的机器上使用过Java应用程序，您已经安装了它。

1．从Oracle的网站上下载JDK。确保不要下载到服务器版本的JRE。

2．确保您获取了开发工具包的Windows版本。

3.正常运行安装程序。

从命令提示符运行Java程序

1.使用记事本或其他文本编辑器创建一个如下所示的简单Java程序。请确保以扩展名“.java”而不是“.txt”保存文件。

2.从开始菜单打开命令提示符。您也可以按Win R，然后在运行字段中输入cmd.exe。

3.使用cd命令将工作目录更改为包含Java程序的目录。我保存在我的“脚本”文件夹中，但是您可以将您的文件保存在系统中的任何位置。

4．在您的计算机上定位到Java开发工具包(JDK)版本的路径。如果你运行64位Windows，那通常是在“C：\ Program Files \ Java”中。

5.使用“set”命令设置JDK的路径，如下所示：

您可能需要更改目录路径以反映当前版本的Java。确保您使用的是Java开发工具包(JDK)目录，并指向“bin”文件夹。Java运行时环境(JRE)文件夹也包含一个“bin”文件夹，但不包含Java编译器。如果在编译过程中出现错误，请确保使用正确的目录路径。

6.使用javac命令编译Java程序，如下所示：

7.你应该看到什么都没有发生。但是，如果您使用dir命令，则会在您的目录中以“.class”扩展名结尾注意到一个新文件。这表示程序已经编译完成。

未来Kotlin取代Java或成为可能

Sat, 30 Jun 2018 21:04:58 +0800

未来Kotlin取代Java或成为可能

Java遇上大麻烦了!一种新的编程语言Kotlin或将取代Java成为Android开发中的主要语言。不过对于外行人来说，Kotlin是什么鬼?Kotlin真的会取代Java吗?今天小编就来说说关于Kotlin的那些事。

Kotlin取代Java是真的吗?

Kotlin 是一个基于 JVM 的新的编程语言，由 JetBrains 开发。Kotlin可以编译成Java字节码，也可以编译成JavaScript，方便在没有JVM的设备上运行。目前Kotlin已正式成为Android官方开发语言，未来Kotlin取代Java还是有希望的。

随着Kotlin的诞生及应用，市场上流传着Kotlin取代Java成为Android开发的主要语言。以下是小编整理的Kotlin的优点及不足：

Kotlin的优点：

对于 Android 开发者而言，Kotlin 有很多优点。Kotlin 完全兼容现有的 Java 工具和函数库，同时能够很好的在 Android Studio 中使用。最明显的是它的类型系统和对空类型的处理，Kotlin 有助于公平的竞争环境。

Kotlin 迈出了 Android 开发的一大步，从一个开发者的经验来看，Kotlin 是 Android 应用开发的未来。对于初学者来说，Kotlin 很简洁，它具备其他现代语言的特性，它由 JetBrains 这样很专业的团队进行持续的开发，同时一直有社区的支持，因为它是开源的!因此可见，未来Kotlin取代Java其实是有迹可循的。

Kotlin的不足：

Kotlin缺乏成熟的模式和广泛的实践，这样就造成了使用Kotlin编写的代码很难得到维护。另一方面来说，如果项目规模较大将很难引入 Kotlin，因为Kotlin 存在的主要问题：静态代码分析工具的缺乏和成熟设计模式的缺乏。从 Kotlin 缺乏静态代码分析工具可以看出来。

虽然 Java 的静态代码分析工具不完美，但它们可以作为衡量技术债务的好指标。Java 工具不能用于 Kotlin，因为它们专门分析的是 Java 语言源码。综合来看，Kotlin取代Java的路还很长。

当前Kotlin的应用已经令很多学习Java的人内心产生动摇，不过从技术面来说，Java的应用并不仅限于Android开发，目前Java被广泛应用于企业级网站开发、游戏开发等方面

Kotlin 扩展函数详解与应用

Fri, 23 Feb 2018 11:31:21 +0800

一、什么是扩展函数？

扩展函数数是指在一个类上增加一种新的行为，甚至我们没有这个类代码的访问权限。这是一个在缺少有用函数的类上扩展的方法，Kotlin能够为我们做到那些令人关注的事情，而这些Java做不到。

在Java中，通常会实现很多带有static方法的工具类，而Kotlin中扩展函数的一个优势是我们不需要在调用方法的时候把整个对象当作参数传入，它表现得就像是属于这个类的一样，而且我们可以使用this关键字和调用所有public方法。

二、扩展函数的使用

（1）函数的扩展

简单来说，Kotlin扩展函数允许我们在不改变已有类的情况下，为类添加新的函数。例如，我们能够为Activity中添加新的方法，让我们以更简单术语显示toast，并且这个函数不需要传入任何context，它可以被任何Context或者它的子类调用，比如Activity或者Service：

fun Context.toast(message: CharSequence, duration: Int = Toast.LENGTH_SHORT) {
 Toast.makeText(this, message, duration).show()
}1
2
3

当然你也可以这样写：

fun Activity.toast(message: CharSequence, duration: Int = Toast.LENGTH_SHORT){
 Toast.makeText(this, message, duration).show()
}1
2
3

对参数的解释：
- Activity：表示函数的接收者，也就是函数扩展的对象
- . ：扩展函数修饰符
- toast：扩展函数的名称

我们可以在任何地方（例如在一个工具类文件中）声明这个函数，然后在我们的Activity中将它作为普通方法来直接使用（这里的两种使用方式后文会做解释）：

override fun onCreate(savedInstanceState: Bundle?) { 
 super<BaseActivity>.onCreate(savedInstanceState)
 toast("This is onCreate!!")
 toast("Hello world!", Toast.LENGTH_LONG)
}1
2
3
4
5

当然了，Anko已经包括了自己的toast扩展函数，跟上面这个很相似（关于Anko是什么，你可以看我的这篇文章。。。）。Anko提供了一些针对CharSequence和resource的函数，还有两个不同的toast和longToast方法：

toast("Hello world!")
longToast(R.id.hello_world)1
2

有一点值得注意：扩展函数并不是真正地修改了原来的类，它的这些作用效果是以静态导入的方式来实现的。扩展函数可以被声明在任何文件中，因此有个通用的方式是把一系列有关的函数放在一个新建的文件里，就像我们刚才所说的工具类当中。

我觉得还是再举几个几个例子来说明一下吧，因为它们完全显示扩展函数的力量。

● 在 Toast 中的高级用法

我们首先看看这个例子：

fun Context.niceToast(message: String,
 tag: String = javaClass<MainActivity>().getSimpleName(),
 length: Int = Toast.LENGTH_SHORT) {
 Toast.makeText(this, "[$className] $message", length).show()
}1
2
3
4
5

我们增加了一个默认值是类名的参数，如果这是在Java中的话，那么总数开销会以几何形式增长，而现在我们可以通过以下方式调用：

我们JAVA开发学习的七大作为

Wed, 29 Nov 2017 19:15:12 +0800

Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。以下是小编搜索整理的关于JAVA开发学习的七大步骤，供参考借鉴，希望对大家有所帮助!

1、多动手

　　学编程语言不仅仅是从理论上的学习，更重要的是要利用这门语言为你的思想服务。理解这门语言是首要的，但是要达到心领神会、融会贯通就必须勤动手，多去时间，多编一些例子。计算机科学是注重实践的学科，成功的软件开发人员无不经过大量的上机锻炼，只有理论和实践相结合才能真正掌握只是和技能。

　　2、多动脑

　　对于Java语言的学习，不仅仅是对语言本身的学习，更重要的是面向对象思想的简历过程，如果想把Java学习提升到一个更高的层次，Java私塾建议从一开始就用面向对象的思维方式去面对你所接触的每件事。

　　3、多查API文档

　　Java提供了大量的类以满足网络化、多线程、面向对象的需要。这就是J2SEAPI，它是Java编程的基本方法，也是编程过程中所不断利用的资源。Java的学习过程不仅仅是基本语法的学习，更多的是去学习和掌握它所提供的API类库。对于所接触到的类，方法，都去仔细去阅读文档的说明，再用自己编写的实例去此时一下。

　　4、约束自己，规范编码习惯

　　养成良好的编码习惯对于一个程序员来讲具有相当大的意义。一方面良好的编程习惯对于减少编码过程中一些人为的错误能起到主动避免的作用;另一方面一段程序写的好坏，不仅仅是功能上的实现，更主要的是可读性，可维护性，没有任何人愿意去阅读一段没有顺序，杂乱无章的代码。建议大家在编码的时候要时刻想到：如果这段代码给别人看，别人是否看得懂，条理是否清楚。

　　5、用有意义的名字

　　名字，是一个标识，是一种有内涵的简单表述。在编写程序的过程中，为每个类、每个方法起一个有意义的名字。在程序阅读的过程中，看到这个名字就可以知道她多完成的功能。

　　6、添加适量的注释

　　注释不仅仅是对程序逻辑处理的一种注释，更多的是提高了程序的可读性和可维护性。做为一个软件产品，哪怕只是一个小小的功能的实现，其中不同的变量及方法可能很多，虽然在命名的过程中要使用有意义的名字，但也不能完全涵盖变量及方法的功能及内涵，多为了提高程序的可读性，添加一定的注释是非常有必要的。合理的注释不仅能起到美化程序的作用还能提高程序可读性和维护性。

　　7、相信自己

　　相信自己包括两方面，一是相信自己的能力，二是相信自己的答案。

　　相信自己的能力就是要相信自己具有解决问题的能力。一个程序员的好坏并不是直接决定于是否能编写出好的代码，更重要的是能否自己去解决调试过程中遇到的任何问题，很少有一个程序员写出的代码一次成功，只有在不断的调试，修正中才能编写出真正的好代码。调试、解决问题的过程就是自己学习提高的过程。

　　相信自己的答案就是要相信自己的程序运行的结果。对于不同的问题在不同的资料上可能有不同的答案，就像小马过河一样，不同的人可能有不同的答案，所以不要去盲目的相信任何人，要相信自己。

五分钟学会 Kotlin 语法

Wed, 29 Nov 2017 11:03:22 +0800

为什么使用Kotlin
项目一期在收尾了终于有时间折腾了，一个多月以来Kotlin从入门到现在，坚持用来开发的切身感受。因为语法与Java的区别挺大的一开始很想放弃，如果不是因为项目在使用，想必很少人会尝试这样一门小众语言，但是习惯后会发现这些年究竟浪费多少时间在写无用的Java代码了，Kotlin在兼容Java的基础上还能大大提升开发效率。Kotlin有许多特性但对于开发来说，快速适应和学习更为重要，很多时候我们都是在不明白其原因就开始使用的，正如我们不可能把Retrofit原理研究透才使用它。只要它足够稳定成熟，并能有效的提升开发效率都是值得尝试的。鄙人不才，目前使用Kotlin的原因主要是因为它语法简洁，支持lambda表达式，强大的when语法，不用写分号结尾，光是这些就足以让我喜欢Kotlin。至于空安全之类的特性，毕竟服务端数据类型太多null了并没多大感触，这些特性在实际应用中潜移默化的就吸收了，以至于现在遇到几个Java编写的代码，都有些不适应了。
修改说明
突然火了一脸懵逼，Google IO的影响真是不容小觑。避免误人子弟还是修改下比较好，也就把上一篇文章的基础知识也搬迁过来，对条件判断when还有空判断处理进行了修改，添加了lambda说明，移除过期链接。
Kotlin 基本语法
先说个学习Kotlin语法的小窍门，将代码用Java写好，然后Code/Conver Java File to Kotlin File转换成Kotlin代码，或者将Java代码复制到Kotlin文件会提示转换也是挺方便的，比较差异很容易就能理解了，一开始难免不适应习惯后相信你一定会喜欢上Kotlin
1). 定义
忘掉Java的那一套写法不然会很不适应的，Kotlin有自己的特性不该被Java的思维所束缚。在Kotlin中常量用val声明，变了用var声明，关键字在前面，类型以冒号:隔开在后面，也可以省略直接赋值，类型后带问号?表示可为空类型(默认空安全)。

常量val延迟加载by lazy{}，默认线程安全关闭线程安全lazy(LazyThreadSafetyMode.NONE){}，变量var延迟加载lateinit。
//常量数组int[][][] arrs = new int[3][2][1];
val arrs = Array(3) { Array(2) { IntArray(1) } }
//空安全变量
var str: String = "hello"
var str1 = "word"
//可为空字符串变量
var str2: String? = null


2). 条件
if...else 正常使用，不过移除了switch用更强大的when替代，when子式可以是常量、变量、返回数值的表达式、返回Boolean值的表达式，强大到用来替换if...else if
// 测试值 x = 0, -1, 1, 2, 3, 6, 10
var x = 10
when (x) {
 //常量
 2 -> println("等于2")
 //数值表达式
 if (x > 0) 1 else -1 -> println("大于0并等于1，或小于0并等于-1")
 //Boolean类型表达式
 in 1..5 -> println("范围匹配1-5")
 !in 6..9 -> println("不是6-9")
 is Int -> println("类型判断")
 else -> println("else")
}
// 代替if...else if
when{
 x > 6 && x <= 10 -> println("大于6小于等于10")
 x < 6 -> println("小于6")
 else -> println("else")
}

3). 循环

java mail实现Email的发送,完整代码

Sun, 26 Nov 2017 18:34:36 +0800

1、对应用程序配置邮件会话

javax.mail.Session保存邮件系统的配置属性和提供用户验证的信息，发送email首先要获取session对象。

(1)Session.getInstance(java.util.Properties)获取非共享的session对象

(2)Session.getDefaultInstance(java.utilProperties)获取共享的session对象

两者都必须建立Properties prop=new Properties()对象;

注意：一般对单用户桌面应用程序使用共享Session对象。

用SMTP协议发送Email时通常要设置mail.smtp.host(mail.protocol.host协议特定邮件服务器名)属性。

prop.put("mail.smtp.host","smtp.mailServer.com");

Session mailSession=Session.getInstance(prop);

注意：在真正使用创建的过程中，往往会让我们验证密码，这是我们要写一个密码验证类。javax.mail.Authenticator是一个抽象类，我们要写MyAuthenticator的密码验证类，该类继承Authenticator实现：

protected PasswordAuthentication getPasswordAuthentication(){
return new PasswordAuthentication(String userName, String password);
}

这时我们创建Session对象：

Session mailSession=Session.getInstance(prop,new MyAuthenticator(userName,Password));

并且要设置使用验证：prop.put("mail.smtp.auth","true");

使用 STARTTLS安全连接:prop.put("mail.smtp.starttls.enable","true");

2、配置邮件会话之后，要编写消息

要编写消息就要生成javax.mail.Message子类的实例或对Internet邮件使用javax.mail.interet.MimeMessage类。

(1)建立MimeMessage对象

MimeMessage扩展抽象的Message类，构造MimeMessage对象：

MimeMessage message=new MimeMessage(mailSession);

(2)消息发送者、日期、主题

message.setFrom(Address theSender);

message.setSentDate(java.util.Date theDate);

message.setSubject(String theSubject);

(3)设置消息的接受者与发送者（寻址接收）

setRecipient(Message.RecipientType type , Address theAddress)、setRecipients(Message.RecipientType type , Address[] theAddress)、addRecipient(Message.RecipientType type , Address theAddress)、addRecipients(Message.RecipientType type,Address[] theAddress)方法都可以指定接受者类型，但是一般用后两个，这样可以避免意外的替换或者覆盖接受者名单。定义接受者类型：

Message.RecipientType.TO：消息接受者

Message.RecipientType.CC：消息抄送者

Message.RecipientType.BCC：匿名抄送接收者(其他接受者看不到这个接受者的姓名和地址)

(4)设置消息内容

JavaMail基于JavaBean Activation FrameWork(JAF)，JAF可以构造文本消息也可以支持附件。

设置消息内容时，要提供消息的内容类型-----即方法签名:

深入理解Java虚拟机到底是什么

Fri, 24 Nov 2017 22:54:49 +0800

什么是Java虚拟机

作为一个Java程序员，我们每天都在写Java代码，我们写的代码都是在一个叫做Java虚拟机的东西上执行的。但是如果要问什么是虚拟机，恐怕很多人就会模棱两可了。在本文中，我会写下我对虚拟机的理解。因为能力所限，可能有些地方描述的不够欠当。如果你有不同的理解，欢迎交流。

我们都知道java程序必须在虚拟机上运行。那么虚拟机到底是什么呢？先看网上搜索到的比较靠谱的解释：

虚拟机是一种抽象化的计算机，通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机有自己完善的硬体架构，如处理器、堆栈、寄存器等，还具有相应的指令系统。JVM屏蔽了与具体操作系统平台相关的信息，使得Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。

这种解释应该算是正确的，但是只描述了虚拟机的外部行为和功能，并没有针对内部原理做出说明。一般情况下我们不需要知道虚拟机的运行原理，只要专注写java代码就可以了，这也正是虚拟机之所以存在的原因--屏蔽底层操作系统平台的不同并且减少基于原生语言开发的复杂性，使java这门语言能够跨各种平台（只要虚拟机厂商在特定平台上实现了虚拟机），并且简单易用。这些都是虚拟机的外部特性，但是从这些信息来解释虚拟机，未免太笼统了，无法让我们知道内部原理。

从进程的角度解释JVM

让我们尝试从操作系统的层面来理解虚拟机。我们知道，虚拟机是运行在操作系统之中的，那么什么东西才能在操作系统中运行呢？当然是进程，因为进程是操作系统中的执行单位。可以这样理解，当它在运行的时候，它就是一个操作系统中的进程实例，当它没有在运行时（作为可执行文件存放于文件系统中），可以把它叫做程序。

对命令行比较熟悉的同学，都知道其实一个命令对应一个可执行的二进制文件，当敲下这个命令并且回车后，就会创建一个进程，加载对应的可执行文件到进程的地址空间中，并且执行其中的指令。下面对比C语言和Java语言的HelloWorld程序来说明问题。

首先编写C语言版的HelloWorld程序。

[cpp]view plain copy

#include

int main(void) {

printf("hello world\n");

return 0;

}

编译C语言版的HelloWorld程序：

[plain]view plain copy

gcc HelloWorld.c -o HelloWorld

运行C语言版的HelloWorld程序：

[plain]view plain copy

zhangjg@linux:/deve/workspace/HelloWorld/src$ ./HelloWorld

hello world

gcc编译器编译后的文件直接就是可被操作系统识别的二进制可执行文件，当我们在命令行中敲下 ./HelloWorld这条命令的时候，直接创建一个进程，并且将可执行文件加载到进程的地址空间中，执行文件中的指令。

作为对比，我们看一下Java版HelloWord程序的编译和执行形式。

首先编写源文件HelloWord.java ：

[java]view plain copy

public class HelloWorld {

public static void main(String[] args) {

}

编译Java版的HelloWorld程序：

[java]view plain copy

zhangjg@linux:/deve/workspace/HelloJava/src$ javac HelloWorld.java

zhangjg@linux:/deve/workspace/HelloJava/src$ ls

HelloWorld.class HelloWorld.java

学习Java编程最有效的方法

Tue, 21 Nov 2017 18:07:45 +0800

有很多的Java程序员，在初期学习时，通常会对如何学习而感到迷茫。下面我就来分析下如何学好Java编程，相信能帮助那些正在处于迷茫状态的初学者。

1、培养兴趣

兴趣是能够让你坚持下去的动力,如果只是把写程序作为谋生的手段的话，你会活的很累，多关心一些行业趣事，多想想盖茨。不是提倡天天做白日梦，但人要是没有了梦想，你觉得有味道吗？

可能像许多人一样，打打麻将，喝喝功夫茶，拜拜财神爷；每个月就有几万十几万甚至更多的进帐，凭空多出个"食利阶层"。你认为，这样有味道吗？有空多到一些程序员论坛转转，你会发现，他们其实很乐观幽默，时不时会冒出智慧的火花。

2、要脚踏实地

快餐式的学习不可取，欲速则不达，浮躁是现代人最普遍的心态，能怪谁？也许是贫穷落后了这么多年的缘故，就像当年的大跃进一样，都想大步跨入共产主义社会。

现在的软件公司、客户、政府、学校、培训机构等等到处弥漫着浮躁之气。社会环境如是，我们不能改变，只能改变自己,闹市中的安宁，弥足珍贵。许多初学者C++/Java没开始学，立马使用VC/JBuilder,会使用VC/JBuilder开发一个HelloWorld程序，就忙不迭的向世界宣告，"我会软件开发了"，简历上也大言不惭地写上"精通VC/Java"。

结果到软件公司面试时要么被三两下打发走了，要么被驳的体无完肤，无地自容。到处碰壁之后才知道捧起《Java编程思想》仔细钻研，早知如此何必当初呀。"你现在讲究简单方便，你以后的路就长了"，好象也是佛经中的劝戒。

3、多实践，快实践

任何事情，一旦考虑好了，就要马上上路，不要等到准备周全之后，再去干事情。假如事情准备考虑周全了再上路的话，别人恐怕捷足先登了。Java软件开发是一门工程学科，注重的就是实践，"君子动口不动手"对软件开发人员来讲根本就是错误的，他们提倡"动手至上"，但别害怕，他们大多温文尔雅，没有暴力倾向，虽然有时候蓬头垢面的一副"比尔盖茨"样。

有前辈高人认为，学习编程的秘诀是：编程、编程、再编程，笔者深表赞同。

不仅要多实践，而且要快实践。我们在看书的时候，不要等到你完全理解了才动手敲代码，而是应该在看书的同时敲代码，程序运行的各种情况可以让你更快更牢固的掌握知识点。

加强英文阅读能力对学习Java编程来说，不要求英语,但不能一点不会,最起码像JAVAAPI文档这些东西还是要能看懂的,连猜带懵都可以；旁边再开启一个"金山词霸"。看多了就会越来越熟练。在学Java的同时学习英文，一箭双雕多好。另外好多软件需要到英文网站下载，你要能够找到它们，这些是最基本的要求,英语好对你学习有很大的帮助。

使用合适的工具工欲善其事必先利其器。软件开发包含各种各样的活动，需求收集分析、建立用例模型、建立分析设计模型、编程实现、调试程序、自动化测试、持续集成等等，没有工具帮忙可以说是寸步难行。

工具可以提高开发效率，使软件的质量更高BUG更少。组合称手的武器。到飞花摘叶皆可伤人的境界就很高了，无招胜有招，手中无剑心中有剑这样的境界几乎不可企及。

从软件开发人员的生涯规划来讲，我们可以大致分为三个阶段，软件工程师→软件设计师→架构设计师或项目管理师。不想当元帅的士兵不是好士兵，不想当架构设计师或项目管理师的程序员也不是好的程序员。我们应该努力往上走。

Java是现在大型软件项目中的主角，市场用人需求量大,大家都知道21世纪进入信息时代，信息科技给人类的生产和生活方式带来了深刻的变革，信息产业已成为推动国家经济发展的主导产业之一，为此，从就业前景，发展方向等多方面来看，学Java编程无疑是最佳选择。

Java精选笔试题

Sat, 11 Nov 2017 20:50:26 +0800

合抱之木，生于毫末；九层之台，起于垒土；千里之行；始于足下。赶快测测你的Java基础知识掌握的如何？

1，volatile关键字是否能保证线程安全？（）

>>>>

答案：否

volatile关键字用在多线程同步中，可保证读取的可见性，JVM只是保证从主内存加载到线程工作内存的值是最新的读取值，而非cache中。但多个线程对volatile的写操作，无法保证线程安全。

假如线程1，线程2 在进行read,load 操作中，发现主内存中count的值都是5，那么都会加载这个最新的值，在线程1对count进行修改之后，会write到主内存中，主内存中的count变量就会变为6；线程2由于已经进行read,load操作，在进行运算之后，也会更新主内存count的变量值为6；导致两个线程及时volatile关键字修改之后，还是会存在并发的情况。

2，下面哪个流类属于面向字符的输入流( )

A、BufferedWriter

B、FileInputStream

C、ObjectInputStream

D、InputStreamReader

>>>>

答案：D

程序员如何高效学习（以 Java 为例）

Thu, 09 Nov 2017 18:10:09 +0800

写在前面：
其实学习是一件很私人的事情，每个人都应该有一套自己的学习方式，而不是照搬照抄别人的。适合别人的不一定适合自己。所以，读这篇分享的时候，请以一种这点是不是对我有帮助的心态来阅读，而不是原来我要这样才能学的好的心态。如果你觉得某一点对你有用，那就记在心里，如果你觉得不太适合你，那么一笑而过就好。

我不是什么大牛，只是一个普通的本科生，有说的不好的地方，还望海涵。也因为我只是一个本科生，没有很多的工作经验，所以对于工作后的一些学习经验比较匮乏，所以文章里大部分说的都是大学时期的一些经验，很抱歉。

这篇文章大体上会从以下几个部分展开：

认清自己
学习目的
时间管理
学习方法
学习的步骤
获取知识的途径
影响学习的几个因素
自己的心态
外物的影响
其他想说的
大学生的学习
一些感悟

一、认清自己

1.1

认清自己最关键的一点是要知道自己到底想要什么。这是第一步，也是最重要的一步。因为这关系到你能够选对学习方向，能否沉下心来去学习。

我们都知道，做自己感兴趣的事情的时候，是可以事半功倍的，因为你愿意去做它，而不是出于某种原因不得不去做。

经常会有人问我，现在前端找工作好找么？java 找工作好找么？我要不要学 android 呢？这些问题的答案其实大家心里都明白：只要你足够优秀，学什么都能够找到一份好的工作。

所以说，不要因为某一个方向火，而盲目的去追；也不要因为某一个方向可能不容易找工作而不去学。

对一个搞技术的人来说，年龄的增长其实不是那么可怕，可怕的是你没有匹配自己年龄的技术深度。当你的工作换一个刚毕业的学生都能做的时候，你很快就会被淘汰了。所以，选方向一定要选自己感兴趣的方向，因为只有这样，你才有兴趣去往深入了学，你才不会在未来被年轻人挤下去。

1.2

认清自己的第二点是认识到人外有人。自满，自大，自欺欺人是影响自己进步的绊脚石。如果你觉得，你现在已经很了不起了，你能做到这个程度已经很不错了，你就会停滞不前，然后浪费大把的时间。

这是我自己的亲身经历。我的学校是一个双非大学，计算机也不是学校很好的专业，消息也比较闭塞。在我的圈子里，我觉得自己已经很不错了，我之前也一直这样认为。但是，当我今年开始准备春招准备校招的时候，我发现我错了，和真正优秀的人比起来，我什么都不是。以前觉得自己会的东西，出去一看，大家其实都会；以前觉得很多知识等工作了再去学也不迟，出去一看，发现早就有人学会了。但是，现在认识到这些已经有点晚了，因为已经开始找工作了，没有时间再去让你从头开始学了。

所以说，永远不要自满，要知道人外有人。如果有一天，你觉得周围没有人比你更厉害了，一定要记得，不是你走到巅峰了，而是你的圈子，应该扩大了。只有你的周围，有很多更厉害的人，你才能意识到自己的不足。这也是我常挂在嘴边的：你想变成什么样的人，你就要去认识什么样的人，你的周围是什么样的人，你就会变成什么样的人。要知道，人以群分。

二、学习的目的

为什么要学习呢？学习的目的，根本上是为了获取竞争优势，增加选择机会。你比别人懂得多，比别人学的深，你就更有竞争力。对于程序员来说，不懂得学习是没有办法在这个行业混下去的。技术的更新换代，技术的深入掌握都需要去不断的学习，如果你不学，很快就会被淘汰了。

找工作的时候，有其他专业的朋友会羡慕的和我说：你这个专业真好，一毕业月薪就上万，我才 3，4 千。其实我想说的是，如果不好好学习技术，搞技术的也会失业。大部分的人都只看到一部分计算机的应届生工资很高很羡慕，却忽略了他们这四年是怎么度过的。天上是不会掉馅饼的，计算机专业的每天看剧打游戏，毕业一样找不到工作。希望以后你不会是那群天天打游戏看剧最后抱怨自己工资低的那群人中的一个。

三、时间管理

知道了自己的方向，知道了为什么要学，那么我们接下来谈一谈，怎么安排自己的时间，或者说，怎么制定一个计划。

很多人应该都有过这样的经历：我现在很无聊，不知道做什么好，学习吧，不知道学什么，打开电脑也不知道做什么，打开手机也不知道做什么，然后只能选择看个直播，看个电视或者打个游戏来打发时间。当一天过去以后，突然后悔，觉得自己当时要是学习就好了。

为什么会这样呢？是因为你自己没有一个计划，如果你每天都有一个按时间段安排的计划的话，你就不会迷茫了，你就会知道这个时间点自己应该做什么，而不是用看剧打游戏来打发时间。

关于时间的管理，首先：

要有一个大一点的计划，比如年计划，月计划，周计划。
这一年大体上要打到什么目标，这个月要学习哪些知识。
然后是精确到小时的日计划。
每一天，哪个时间段做什么都详细的列出来。

其次，不要太盲目自信。很多人其实从来没有完成过自己的计划。如果你真的能够完成你制定的每一个计划，那现在的你一定已经很了不起了。如果你几乎没有完成过自己的计划，那么你一开始制定日计划的时候，不要给自己太多的任务。因为如果你一旦完不成，就会影响自己的信心。最好的方式是，一开始制定一些简单的计划，然后每天很容易就能做到，然后慢慢的去增加自己每天的任务量。最后找到一个最适合自己的节奏。这个过程可能需要很长的时间，因为你要不断的去尝试，去改进。找到最适合自己的作息时间去休息，找到自己工作状态最好的时间去工作等等。

最后，不要把你的计划当摆设。虽然我上面说过，很多人其实从来没有完成过自己的计划。但是我还是希望你能够认真的去对待它，因为受益的有且只有你自己。

四、学习方法

盲目的学习效果并不好。以前看书的时候，看完一遍再从头看，感觉就像是在看一本新书，完全没有印象。看似自己学了不少，其实真正掌握到的并不多。学习不是你看得书越多，读过的文章越多你就学的越好，而是看你究竟掌握了多了。那么，怎么才能有效的去学习一门新的技术呢？我总结了以下几个步骤。

Java小技巧，从运行、控制到框架

Wed, 08 Nov 2017 19:17:52 +0800

1. JVM相关

JVM作为java运行的基础，很难相信对于JVM一点都不了解的人可以把java语言吃得很透。我在面试有超过3年Java经验的开发者的时候， JVM几乎就是一个必问的问题了。当然JVM不是唯一决定技术能力好坏的面试问题，但是可以佐证java开发能力的高低。

在JVM这个大类中，我认为需要掌握的知识有：

JVM内存模型和结构

GC原理，性能调优

调优：Thread Dump，分析内存结构

class 二进制字节码结构， class loader 体系， class加载过程，实例创建过程

方法执行过程

Java各个大版本更新提供的新特性(需要简单了解)

2. Java的运行（基础必备）

这个知识点是最最基本的java开发者需要掌握的，初学java，第一个肯定是教你如何在命令行中执行java程序，但是很多人一旦把java学完了，IDE用上了，就把这个都忘了。为什么强调要知道这个呢，知道了java最纯粹的启动方式之后，你才能在启动出问题的时候，去分析当时启动的目录多少，执行命名如何，参数如何，是否有缺失等。这样有利于你真正开发中去解决那些奇奇怪怪的可能和环境相关的问题。

在这里需要掌握的知识有：

javac 编译java文件为 class 文件

java 命令的使用，带package的java类如何在命令行中启动

java程序涉及到的各个路径(classpath， java。library。path， java运行的主目录等)

3. 数据类型

这条没有什么好多说的，无非就是Java中的基本类型和对象类型的掌握。可以再了解一些JDK如何自动转换方面的知识，包括装箱拆箱等，还要注意避免装箱之后的类型相等的判断

主要知识点：

基本类型： int， long， float， double， boolean ，。。。

JAVA的图案为什么是咖啡

Mon, 06 Nov 2017 18:19:56 +0800

JAVA的图案为什么是咖啡？

在学习JAVA的时候

看到了JAVA的图案

是一杯咖啡

有没有好奇的呢？

有的话，我们一起来探讨探讨

第一个版本

2000年度的JavaOne国际会议大厅热闹非凡，一阵阵浓郁的咖啡味儿香气扑鼻。从世界各地汇集到旧金山参加会议的Java精英们兴奋异常，排着长队，等待得到一杯由Java语言控制的咖啡机煮制的免费咖啡。这是一个特殊设计的全透明咖啡机。当您按下按钮时，咖啡豆从玻璃管输送到研磨器。磨制后的咖啡粉由另一个玻璃管送到煮制机。沸腾的水滴入咖啡粉中，一杯醇香四溢的咖啡传送到您的手中…由此可见JAVA和咖啡有着不解之缘。

第二个版本

最初这个为TV机顶盒所设计的语言在公司内部一直称为Green项目。“我们的新语言需要一个名字。” 简姆斯.古斯林一直在考虑这个问题。有一天，简姆斯古斯林注意到自己办公室外一棵茂密的橡树Oak，这是一种在硅谷很常见的树。所以他将这个新语言命名为Oak。但Oak是另外一个注册公司的名字。这个名字不可能再用了。如果通过正式程序来注册产品的名称将即费时又费钱。简姆斯古斯林决定通过市场部门，请来了一个命名顾问，召开命名征集会。当时，因为没有一个合适的名字，他们不得不延后这个语言的面世。在命名征集会上，大家提出了很多名字。最后按大家的评选次序，将十几个名字排列成表，上报给商标律师。排在第一位的是Silk（丝绸）。尽管大家都喜欢这个名字，但遭到简姆斯古斯林的坚决反对而作罢。排在第二和第三的都没有通过律师这一关。简姆斯古斯林最喜欢的就是排在第三位的Lyric（抒情诗）。只有排在第四位的名字、得到了所有人的认可和律师的通过。这个名字就是Java。

第三个版本

还有一种说法是马克奥颇门一家咖啡店与同事品尝咖啡时得到灵感的。Java是印度尼西亚爪哇岛的英文名称，因盛产咖啡而闻名。国外的许多咖啡店用Java来命名或宣传，以彰显其咖啡的品质。

Java语言中的许多库类名称，多与咖啡有关。JavaBeans（咖啡豆）、NetBeans（网络豆）以及ObjectBeans （对象豆）等等。从此一个即好听又好记、具有强大的生命力的编程语言Java诞生了。

Java小技巧，从运行、控制到框架

Mon, 06 Nov 2017 18:19:27 +0800

1. JVM相关

在JVM这个大类中，我认为需要掌握的知识有：

JVM内存模型和结构

GC原理，性能调优

调优：Thread Dump，分析内存结构

class 二进制字节码结构， class loader 体系， class加载过程，实例创建过程

方法执行过程

Java各个大版本更新提供的新特性(需要简单了解)

2. Java的运行（基础必备）

在这里需要掌握的知识有：

javac 编译java文件为 class 文件

java 命令的使用，带package的java类如何在命令行中启动

java程序涉及到的各个路径(classpath， java。library。path， java运行的主目录等)

3. 数据类型

主要知识点：

基本类型： int， long， float， double， boolean ，。。。

对应的对象类型： Integer 等类型到基本类型的转换，装箱和拆箱

Object类型： equals， hashcode

String 类型的特点

4. 对象和实例，对象的创建

在这方面，开发者需要了解class和instance的概念以及之间的差别，这是java面向对象特性的一个基础。主要知识点有：

Class和 Instance 的概念

Instance 创建的过程：

Java项目实战经验—程序员成长的钥匙

Sun, 05 Nov 2017 19:49:28 +0800

Java就是用来做项目的！Java的主要应用领域就是企业级的项目开发！要想从事企业级的项目开发，你必须掌握如下要点：

1、掌握项目开发的基本步骤

2、具备极强的面向对象的分析与设计技巧

3、掌握用例驱动、以架构为核心的主流开发方法

没有人愿意自己一辈子就满足于掌握了一些代码实现的技巧，别人告诉你要实现什么，你就用代码堆砌来实现别人的要求！你必须学会从整个项目的角度去思考！你必须学会假如你是项目经理，你该如何思考！你必须学会假如你是架构师，你该如何思考！你必须掌握针对某个特定问题领域的分析方法！

关于基础知识：你可以看看这些名词或知识点，看是否能说出个一二三四来。

JavaSE

----基本语法、数据类型、操作符等：int、long、Integer、Long、if、else、for、while

----面向对象：class（类）、Object（对象）、instance（实例）、state（状态）、behavior（行为）、field、method、new、可见性（访问控制）、attribute、property、package、import、static variable、class variable、instance variable、heap、method area、stack、GC（垃圾回收）、override、overload、对象转型(casting)、多态、this、super

----异常处理：理解编译期错误和运行期错误的区别、Exception、RuntimeException、checked exception、unchecked exception、try、catch、finally、throw new XXXException、throws XXXException、异常处理的基本原则

----数组与集合：数组的定义和使用方法、Collection、List、Set、Map、ArrayList、HashSet、HashMap、Iterator、equals、hashCode、Comparable、Comparator

----常用类：String、intern、常量池、StringBuffer、java.util.Date、SimpleDateFormat、Regex（正则表达式）

----反射机制：Class、Method、Field、invoke、newInstance、BeanUtils（apache-commons）、PropertyUtils（apache-commons）

----输入输出流：InputStream、OutputStream、Reader、Writer、Adapter设计模式与原始流类、Decorator设计模式与包装流类、对象序列化和反序列化

----多线程：Thread、Runnable、sleep、wait、notify、synchronized、lock

Servlet和JSP

----HttpServlet、doGet、doPost、HttpServletRequest、HttpServletResponse、request.getParameter()、request.setAttribute()、request.getAttribute()、request.getSession()、ServletContext、Filter、web.xml、tomcat、forward与redirect、http协议的无状态性、cookie、JSP Scope Object、、

HTML与JavaScript

----你需要能够理解常见的网页标签、理解在网页中引入JavaScript的方法、以及JavaScript的基本语法与使用方法

以上，就是你进一步学习Java所必备的基本知识。特别是一些个专业术语和名词，看到这些名词，如果你像看到亲爹一样亲切，那么说明你对Java的基础知识就很熟悉了。

接下来是SSH：

对于初学者来说，这三大框架被赋予了太多神秘的色彩，似乎它们是重中之重的知识！但是对于拥有多年Java开发经验的专业技术人员来说，对于那些Java牛人来说，却对这三大框架不太感冒！难道它们不重要吗？

现在很多企业都在用这三大框架，所以很多企业也把掌握这三大框架作为招聘的必备条件。不可否认的是，也有很多大型企业没有用这三大框架，这些企业经过多年发展，自身已经有一定的技术积累，也形成了自己独特的技术框架体系。这三大框架既可以说很重要，也可以说不重要。

说重要的原因在于：这三大框架对JavaEE开发中所存在的普遍的问题，提供了优美的解决方案，它们蕴含了这个行业中最NB的开发人员的努力和想法，所以，学习这三大框架，你就可以窥探到这些处于技术巅峰的牛人们究竟对一个问题是怎么想的，通过一种什么样的设计思路去解决问题的。所以，对于你来说，你没有太多项目开发的经验，经验是什么？经验就是你知道可能会遇到哪些问题，针对哪个问题可以有哪些解决方法，在某个情景下，哪种解决方法是较好的，哪种方法不太好等等！如果你没做过什么项目，你根本就不会去意识到你可能会遇到哪些问题，而这些问题往往又是非常关键的！解决得不好，会影响到你的程序的稳定性、可扩展性等等！三大框架就给初学者提供了了解你以后可能会遇到哪些问题，以及针对这些问题的解决方案！

当你了解了这三大框架为什么是重要的，那么你也就能理解，为什么这三大框架也可以说是不重要的。如果你曾经开发过很多项目，你碰到了各种各样的问题，凭着你的技术功底，逐个击破了这些问题，在这些人眼里，三大框架（是不是还有N个框架？呵呵）都是浮云！

你属于哪一种人呢？如果你没有太多项目开发经验，那么三大框架对于你来说就是非常重要的！而且，由此你也知道了该怎么去学这三大框架。对于三大框架的学习而言，着力点在于给你展示问题，并触发你自己主动的思考，我们鼓励你提出自己的想法，也许你的想法很白痴，但那毕竟是你自己的想法，如果你不知道牛人的想法，那你怎么知道自己的想法是很白痴的呢？在这种思想的碰撞过程中，你就会逐渐提高自己！所以，三大框架学完之后，你不应该只是看到一大堆配置文件，你不应该只是看到了一些Action，一些Service，一些映射文件，你不应该只知道session.save/update/delete，你不应该只是知道struts2中有一堆interceptor，你不应该只是看到一堆jar包……

如果你只是知道拷贝一堆jar包，定义一系列配置文件之后，SSH三大框架就能够运行起来了，也可以给你干活了，那么，很悲哀的是，你仍然没有掌握三大框架的精粹！请你回答以下问题：

Struts2：

为什么每次请求都要创建一个Action对象？

ModelDriven拦截器的配置中refreshModelBeforeResult解决了什么问题？

为什么在web.xml中配置的StrutsPrepareAndExecuteFilter要过滤所有的请求？

请你给我谈谈ValueStack？

Struts2是如何实现MVC设计模式的？

Spring：

你为什么要用Spring？

请你聊一聊IOC/DI？

什么是声明式的事务管理？为什么要使用声明式的事务管理？Spring如何实现声明式的事务管理？

把spring和hibernate集成，定义事务管理特性的时候，为何要将除了添加、删除、更新操作之外的方法，即主要执行查询任务的方法定义为read-only？

Hibernate：

请你谈谈你对OR映射的理解？

很多人说Hibernate不适合大项目，性能有问题，你是如何理解的？

Hibernate为什么一定要定义一个数据库标识？

为什么Hibernate建议你的实体类实现hashCode和equals方法？

谈谈你对Hibernate实体类中的数据库标识与数据库主键之间关系的认识？

谈谈你对Hibernate关联映射与数据库外键之间关系的认识？

调用session.save()方法，hibernate一定会发出insert语句吗？谈谈你的理解

调用session.update()方法，hibernate一定会发出update语句吗？谈谈你的理解

请你聊一下以下名词、概念或用法：lazy、lazy=”extra”、inverse、fetch、fetch=”join”、fetch=”subselect”、batch-size

配置了lazy=”true”一定会实现懒加载吗？

请你谈谈Hibernate中的“N 1”问题

请你谈谈Hibernate有哪些最佳实践？

以上并非SSH中全部重点的问题，但它们能考察你能否灵活运用SSH框架！如果你能深刻理解这些问题，再配以合适的实战项目训练，你也会逐渐成为牛人！

最后是项目开发能力：

不管你是学Java还是别的技术，你的根本目的在于给客户创造价值！否则，你下大力气学习的东西，随着技术的进步和更新，很快就会过时！所以，技术的核心在于用技术创造有价值的成果！也就是说，客户需要什么，你就要用技术把客户需要的东西给他造出来！一个公司之所以要用各种福利条件极力挽留你，是因为你能够给公司带来极高的利益！那么，你有什么可以给公司利用的呢？公司最看重你的哪方面的能力呢？

java多线程高级教程，这些你都懂了吗？

Thu, 02 Nov 2017 23:21:04 +0800

一、countdownLatch和cyclicbarrier（这两个做多线程控制很好用，工作中会经常用到）

countdownLatch：主线程阻塞，当多个线程countdown到0，主线程执行；

cyclicbarrier：多个线程等待，当都处于等待状态了一起执行（类似于赛跑机制）

countdownLatch

cyclicbarrier

二、volatile和threadlocal

这两个也要很好掌握，不仅常用，而且面试时候也经常问到！

volatile:使属性可见性。有个属性是共享属性，这个关键字会在每个线程内开一块内存，每次子线程都会从主线程拿最新的属性放到内存中。但是有个问题，他只是拿最新的，比如：计数器，每个线程都执行+1操作。一个线程+1，另外两个同时读取这个属性，那么不会加2次，而是只加一次，这就是valatile不能保证原子性的原因。

threadlocal：用于做方法外的全局属性。这个跟volatile刚好相反，使全局变量独立，每个线程里都有一份独立副本。

这是hibernate的源码，如果当前线程没有session就openSession放到ThreadLocalMap中，每个线程的session都是独立的不会相互受影响。

三、AtomicInteger：支持原子性计数器。

之前说volatile不能作为计数器，那么多线程计数器要用atomic类的AtomicInteger

四、并发类容器

ConCurrentHashMap、CopyAndWriteArrayList、CopyAndWriteArraySet。

ConCurrentHashMap（底层分成16个hashtable来保证并发）读支持高并发读，写和删除时候只支持16个线程，所以一般也要上锁； copyandwrite支持高并发读，写的话要加锁（原理是，写的时候赋值一个容器，写好了把指针指向新容器并且删除原容器）

map、list、set都有并发类容器。面试时候经常会问hashmap和ConCurrentHashMap区别。这个demo我就不写了，用法和我们平时用的集合都一样，只是他们不会造成线程不安全。

五、并发类队列

阻塞的意思是，当达到队列最大容量或者为空，线程还往里加东西或取东西会被阻塞；有界意思，可以设置队列大小。

（非阻塞队列）ConcurrentLinkedQueue无阻塞无界限队列（高并发性能最好，peek取出不删除，poll取出删除），

（阻塞队列）ArrayBlockingQueue阻塞有界队列，LinkBlockingQueue阻塞无界队列（生产者消费者首选，take方法会阻塞，poll方法没有就返回null）。

这里我们以最经典的生产者消费者模式作为例子

这里我们顺便做一个延伸，我们用的所有线程池，包括面试时候经常问的要你自定义一个线程池怎么做？我们先看一下线程池的源码。

也就是说线程池也是用并发队列作为线程的容器。我们自定义时候也只需要重现实例化ThreadPoolExcutor，设置我们自己需要的参数即可。

六、分布式锁

这个其实已经不属于java代码范畴，但是我上一篇讲基础的时候，一些兄弟说我说的太简单，另一些又说太难，所以我加了一个分布式锁，希望能满足更多人需求。

分布式锁，主要用在分布式集群上，既然是分布式，那就有多个jvm，即使你代码写出花来也不能控制。所以只有一个办法就是借助第三方工具。比如memcache、redis、zk

1. 首先明确一点，有人可能会问是否可以考虑采用ReentrantLock来实现，但是实际上去实现的时候是有问题的，ReentrantLock的lock和unlock要求必须是在同一线程进行，而分布式应用中，lock和unlock是两次不相关的请求，因此肯定不是同一线程，因此导致无法使用ReentrantLock。

2. 基于数据库表做乐观锁，用于分布式锁。

3. 使用memcached的add()方法，用于分布式锁。

Java入门学习进阶知识点汇总

Wed, 01 Nov 2017 20:04:15 +0800

入门阶段，主要是培养Java语言的编程思想。了解Java语言的语法，书写规范等，掌握Eclipse、MyEclipse等开发工具，编写Java代码的能力。学完这个阶段你应该可进行小型应用程序开发并且可以对数据库进行基本的增删改查管理。

注意：此阶段知识点的学习，需要真实的项目进行驱动学习，让你轻松理解各知识点。

1 计算机基础知识

针对零基础学习的人，从对计算机操作等知识的了解，延伸到Java语言的发展与开发工具的使用上。主要是了解怎样执行计算机命令，认识Java这门语言，感受编程语言Java怎么开发程序。

(1) 计算机基础

零基础学习的人先了解计算机相关知识，进而再去了解Java语言。

(2) DOS常用命令

了解什么是DOS，并掌握DOS控制台的打开方式，同时熟悉常用的DOS命令，例如：盘符切换、进入指定目录、删除文件等，完成使用DOS命令对计算机进行操作和控制。

(3) Java概述

了解Java语言的发展史、Java语言平台版本、Java语言的特点，以及JRE与JDK。JRE是Java的运行环境，JDK是Java开发工具包，它包含了Java的开发工具以及JRE。所以安装了JDK就不用再单独安装JRE了。

(4) JDK环境安装配置

了解了什么是JDK，以及JDK的重要性，下一步我们就来学习如何安装和配置JDK环境。在安装JDK之前，我们首先需要下载JDK，针对不同的系统，我们需要下载不用版本的JDK。

(5) 环境变量配置

了解path、classpath环境变量，理解path变量和classpath变量的作用，并掌握path变量和classpath变量的配置方式。

(6) Java程序入门

当JDK、环境变量配置完毕，我们就可以开始编写Java程序。编写Java程序可以使用如下几种工具：notepad（微软操作系统自带）、Editplus、Notepad++、Eclipse、MyEclipse。

2 编程基础

此模块学习主要是了解编程的具体流程，学习Java基础语法的格式等。具体要掌握不同数据类型的变量定义与使用，掌握不同运算符的运算规则，掌握流程控制语句的执行流程，编写方法的声明与调用，创建数组并访问数组元素等知识。

(1) 注释

在程序开发工程中，用于解释和说明程序的文字我们称之为注释，Java中的注释分为以下几种：单行注释、多行注释、文档注释。

(2) 关键字

了解Java关键字的含义及特点，掌握关键字使用的注意事项。

( 3) 标识符

了解什么是标识符，标识符的组成规则，以及标识符使用时的注意事项。

( 4) 常量与变量

理解常量与变量的含义，并掌握常量与变量的区别、变量的定义格式以及变量的赋值。

( 5) 数据类型

掌握Java语言的数据类型，如基本数据类型：byte、short、int、long、float、double、char、boolean，以及引用类型：类、接口、数组。

Java在各个操作系统中的安装方式

Mon, 30 Oct 2017 17:43:48 +0800

前言

Java安装应该是件非常简单的事情，不知何时在Oracle官方下载JDK时，竟然强制要求用户登陆。这样就不能通过Linux命令wget下载了，真是有点让人火大。

想了个办法破解这种恶心的cookies验证行为！

对大数据感兴趣的朋友可以加群大数据视频学习交流群 675590728

Java在Windows中安装
Java在Linux Ubuntu中安装

1 Java在Windows中安装

Java环境安装，是指Java开发环境的安装，包括JDK安装和Java的环境配置。在Windows中，很多的Java应用通过JRE就可以运行。但对Java的开发者来说，我们需要安装JDK，必须Oracle SUN官方发布的JDK。

在Windows系统上安装JDK是件非常简单的事情，对大数据感兴趣的朋友可以加群大数据视频学习交流群 675590728

大家可以下载最新版本的Java SE 8，或者较早的JDK版本。本文中使用的是1.6.0_45版本的JDK。

下载后，双击安装。我安装在目录: D: oolkitjavajdk6

安装好JDK后，配置环境变量：

选择：控制面板 –> 系统和安全 –> 系统属性 –> 高级 –> 环境变量

# 新建JAVA_HOME变量JAVA_HOME=D:	oolkitjavajdk6# 新建PATH变量PATH=D: oolkitjavajdk6in

注：如果PATH变量已存在，则在最后增加JDK的路径，用分号(;)与上个配置做分隔。

保存后，打开CMD命令窗口，测试Java的命令行操作。

# 查看Java安装版本~ C:UsersAdministrator>java -versionjava version "1.6.0_45"Java(TM) SE Runtime Environment (build 1.6.0_45-b06)Java HotSpot(TM) 64-Bit Server VM (build 20.45-b01, mixed mode)# 测试Java命令~ C:UsersAdministrator>javaUsage: java [-options] class [args...] (to execute a class) or java [-options] -jar jarfile [args...] (to execute a jar file)where options include: -server to select the "server" VM -hotspot is a synonym for the "server" VM [deprecated] The default VM is server. -cp-classpathA ; separated list of directories, JAR archives, and ZIP archives to search for class files. -D=set a system property -verbose[:class|gc|jni] enable verbose output -version print product version and exit -version:require the specified version to run -showversion print product version and continue -jre-restrict-search | -jre-no-restrict-search include/exclude user private JREs in the version search -? -help print this help message -X print help on non-standard options -ea[:...|:] -enableassertions[:...|:] enable assertions -da[:...|:] -disableassertions[:...|:] disable assertions -esa | -enablesystemassertions enable system assertions -dsa | -disablesystemassertions disable system assertions -agentlib:[=] load native agent library, e.g. -agentlib:hprof see also, -agentlib:jdwp=help and -agentlib:hprof=help -agentpath:[=] load native agent library by full pathname -javaagent:[=] load Java programming language agent, see java.lang.instrument -splash:show splash screen with specified image# 测试Javac命令~ C:UsersAdministrator>javac用法：javac <选项> <源文件>其中，可能的选项包括： -g 生成所有调试信息 -g:none 不生成任何调试信息 -g:{lines,vars,source} 只生成某些调试信息 -nowarn 不生成任何警告 -verbose 输出有关编译器正在执行的操作的消息 -deprecation 输出使用已过时的 API 的源位置 -classpath <路径> 指定查找用户类文件和注释处理程序的位置 -cp <路径> 指定查找用户类文件和注释处理程序的位置 -sourcepath <路径> 指定查找输入源文件的位置 -bootclasspath <路径> 覆盖引导类文件的位置 -extdirs <目录> 覆盖安装的扩展目录的位置 -endorseddirs <目录> 覆盖签名的标准路径的位置 -proc:{none,only} 控制是否执行注释处理和/或编译。 -processor[,,...]要运行的注释处理程序的名称；绕过默认的搜索进程 -processorpath <路径> 指定查找注释处理程序的位置 -d <目录> 指定存放生成的类文件的位置 -s <目录> 指定存放生成的源文件的位置 -implicit:{none,class} 指定是否为隐式引用文件生成类文件 -encoding <编码> 指定源文件使用的字符编码 -source <版本> 提供与指定版本的源兼容性 -target <版本> 生成特定 VM 版本的类文件 -version 版本信息 -help 输出标准选项的提要 -Akey[=value] 传递给注释处理程序的选项 -X 输出非标准选项的提要 -J<标志> 直接将 <标志> 传递给运行时系统

这样我们就在Windows的系统中，配置好了Java环境。

2 Java在Linux Ubuntu中安装

Java安装，指定的是SUN Oracle官方的JDK软件包，而不是Linux Ubuntu系统中通过apt-get安装的OpenJDK。

注：请一定注意版本，必须使用SUN Oracle官方的JDK软件包

在Linux Ubuntu中，下载并安装JDK，这里我选择安装Java SE 1.6.45的64位版本的JDK。

2.1 下载JDK

不知道Oracle官方网站时候调整的JDK下载需要先登陆，因此直接使用wget命令，无法完成JDK的下载。

我们有下面2种解决方法：

1). 从浏览器中登陆下载，然后再传到Linux的服务器

GitHub 上最火的 Java 框架

Sat, 28 Oct 2017 20:30:26 +0800

Java 是目前最需要的编程语言之一。在这里，我们已经挖掘了一些关于框架趋势的有用信息，也就是最受开发者青睐的 Java 框架，名单如下

Spring MVC

网页链接

自从 10 多年前的第一次发布之后，SpringMVC 老当益壮，继续保持着领头羊的地位。在其完全拥抱 MVC 框架之后，Spring 不断的发展与变化着，转变成了一个功能全面的面向互联网应用程序的 Java 框架, 它能提供给软件工程师的是一个用于 Web 应用程序开发的强大工具集，以及针对安全项目的应用程序配置。具有如下特性：

● 简单的 POJO 测试数据注入方式。

● 增强过的模块化，因此拥有更好的代码可靠性。

● 不同模块之间解耦和。

● 能灵活运用的依赖注入（DI）。

Spring Boot

网页链接

Spring Boot 项目旨在简化创建产品级的 Spring 应用和服务。你可通过它来选择不同的 Spring 平台。可创建独立的 Java 应用和 Web 应用，同时提供了命令行工具来允许 'spring scripts'。Spring Boot 不生成代码，完全无需 XML 配置。

深入解析Java垃圾回收机制

Mon, 23 Oct 2017 21:41:45 +0800

引入垃圾回收哪些内存需要回收？引用计数法可达性分析如何回收 Marking 标记 Normal Deletion 清除 Deletion with Compacting 压缩为什么需要分代收集？ JVM的分代新生代老年代永久代分代垃圾收集过程详述引入垃圾回收

JAVA

程序计数器、虚拟机栈、本地方法栈3个区域随线程而生，随线程而灭；栈中的栈帧随着方法的进入和退出而有条不紊地执行着出栈和入栈操作。每一个栈帧中分配多少内存基本上是在类结构确定下来时就已知的（尽管在运行期会由JIT编译器进行一些优化，但在本章基于概念模型的讨论中，大体上可以认为是编译期可知的），因此这几个区域的内存分配和回收都具备确定性，在这几个区域内就不需要过多考虑回收的问题，因为方法结束或者线程结束时，内存自然就跟随着回收了。而Java堆和方法区则不一样，一个接口中的多个实现类需要的内存可能不一样，一个方法中的多个分支需要的内存也可能不一样，我们只有在程序处于运行期间时才能知道会创建哪些对象，这部分内存的分配和回收都是动态的，垃圾收集器所关注的是这部分内存—–《深入理解Java虚拟机》自动垃圾回收机制就是寻找Java堆中的对象，并对对象进行分类判别，寻找出正在使用的对象和已经不会使用的对象，然后把那些不会使用的对象从堆上清除。自动垃圾回收机制就是要解决三个问题：

哪些内存需要回收？什么时候回收？如何回收？哪些内存需要回收？

引用计数法

对于第一个问题，也就是判断是否还需要使用，最简单的方法就是通过目前是否有引用指向这个对象，如果没有就说明这个对象不会再被使用了，如果有就说明这个对象可能还会继续被使用，这种通过引用是否存在的方法就叫做引用计数法，但这个方法存在一个问题就是无法解决对象循环引用的问题，因此又出现了可达性分析的方法来判断对象是否可以被会回收。

可达性分析

这个算法的基本思路就是通过一系列的称为“GC Roots”的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为引用链（Reference Chain），当一个对象到GC Roots没有任何引用链相连（用图论的话来说，就是从GC Roots到这个对象不可达）时，则证明此对象是不可用的。在Java语言中，可作为GC Roots的对象包括下面几种：

虚拟机栈（栈帧中的本地变量表）中引用的对象。方法区中类静态属性引用的对象。方法区中常量引用的对象。本地方法栈中JNI（即一般说的Native方法）引用的对象。如何回收

垃圾收集器通常会帮我们在后台自动进行垃圾回收。关于具体的回收过程只要有以下这些步骤

Step 1: Marking 标记第一步就是标记，也就是垃圾收集器会找出那些需要回收的对象所在的内存和不需要回收的对象所在的内存，并把它们标记出来，简单的说，也就是先找出垃圾在哪所有堆中的对象都会被扫描一遍，以此来确定回收的对象，所以这通常会是一个相对比较耗时的过程

Step 2: Normal Deletion 垃圾收集器会清除掉上一步标记出来的那些需要回收的对象区域

分享优秀Java程序员应有的编程风格

Sun, 22 Oct 2017 21:36:06 +0800

今天突发奇想，对编码习惯和编程风格很感兴趣，于是乎，找了一下关于编程风格（Java篇）的资料，希望对爱好编码或者开始学习编码的同学有帮助！

来自《The Elements of Java Style》-《Java编程风格》一书，值得一读的书籍，会让你在细节上节省很多时间，合作之间更加愉快！

好处不多说了，但是有几个原则如下：

1.保持原有风格

2.坚持最小惊奇原则

3.第一次就做对

4.记录所有非规范行为

格式规范：

1.缩进嵌套的代码：在每个代码块和嵌套中加入缩进，缩进代码，加强可读性。这些地方包括【类定义，内部类定义，方法定义，静态块，for循环语句，if-else语句，try、catch和finally块，匿名内部类，while语句，do-while语句】

2.断开很长的句子：第一，如果包含了逗号，那么在每一个逗号后面都另起一行，把逗号后面的每一个表达式都和逗号前面的表达式的第一个字母对齐。第二，应该在优先级最低的运算符之前断行。

3.使用空白：关键字和左括号之间，右括号和紧随其后的关键字，除了”.”之外的运算符与其前后的表达式之间用空格隔开。每个逻辑上独立的方法和代码段之间，定义类或者接口的成员之间，每个类和接口之间应该加入空白行。

4.不要直接使用Tab控制符：不同环境对Tab控制符的解释也是不同的。

命名约定：

1.名称应该具有实际意义

2.使用人们熟悉的名称

3.谨慎使用过长的名字，可以使用简明通用的缩写

4.尽量保留元音字母

5.缩写词的第一个字母大写

6.不要使用大小写来区分的名字

包命名：

1.用你所在组织的域名的倒序小写形式作为包的根限定词

2.使用单独的小写词作为每个包的根名

3.仅当新旧版本二进制兼容的时候，其包可以使用相同的名字，否则，请使用新名字

类型命名：

1.类和接口名中的每个单词的第一个字母大写

类命名：

1.用名词命名类

2.具有成组相关属性，静态服务或者常量的类名字使用复数形式

接口命名：

1.用名词或者形容词命名接口

方法命名：

1.方法名中的第一个单词小写，其后每个单词的第一个字母大写

2.用动词命名方法

3.遵循JavaBean中命名属性访问函数方法：set，get，is

变量命名：

1.变量命中的第一个单词小写，其后的每个单词的第一个字母大写

2.用名词命名变量

3.集合引用名要用复数形式

4.为不重要的临时变量简历并使用一套标准名字

字段命名：

1.使用this字段变量可以区分开局部变量

参数命名：

1.构造函数或者”set”方法给字段分配参数赋值，参数名应该和字段名相同

常量命名：

1.常量的每个单词均大写，单词之间使用下划线连接

文档约定：

1.为使用和维护你的代码的人编写文档

2.注释和代码要同步

3.使用积极的语气，省略无用的词语

注释类型：

1.用文档注释来描述编程接口

2.用标准注释格式隐藏代码而不必删除它们

3.用单行注释解释实现细节

文档注释：

1.在编写代码前描述编程接口

2.为公用，受保护，包，私有成员建立文档

3.为每个包编写总结和概述

4.为包的每个应用程序或组编写概述

注释风格：

1.对所有文档注释使用统一的格式和组织结构

2.关键字，标识符和常量应放到…标签中

3.将代码放入

…标签中

4.在标识符第一次出现的时候用{@link}标签

5.为Javadoc标签简历并使用一套固定的顺序

6.使用第三人称叙述的形式

Java字符串的10大热点问题盘点

Wed, 18 Oct 2017 20:04:33 +0800

下面我为大家总结了10条Java开发者经常会提的关于Java字符串的问题，如果你也是Java初学者，仔细看看吧：

1、如何比较字符串，应该用”==”还是equals()？

总的来说，”==”是用来比较字符串的引用地址，而equals()才是比较字符串的值。两个值相同的字符串用”==”比较结果有可能是false，而用equals()则一定为true。除非两个字符串是同一个new出来的对象，不然比较字符串值是否相同应该要用equals()。

2、对那些安全敏感的信息，为什么用char[]存储要优于String？

String是不可变的，这就意味着它一旦被创建，就将永久驻留在内存中，直到垃圾回收器将其回收为止。然而用数组存储方式，你可以明确地改变数组中的元素，因此用数组方式，安全信息将有可能不存在系统内存的任何地方。

3、能否用字符串来声明switch语句？

JAVA 7及以后的版本是支持的。在JDK 7中，允许你使用字符串做switch语句的比较条件。jdk 6以前的版本，不能这样使用：

// java 7 only!switch (str.toLowerCase()) {      case "a":           value = 1;           break;      case "b":           value = 2;           break;
}

4、如何将字符串转换成数字int类型？

int n = Integer.parseInt("10");

很简单，但却会经常用到，也很容易被忽略。

5、如何用空格字符来分割字符串？

我们可以很方便地用正则表达式来分割字符串，”\s”表示空格字符，比如” “, “\t”, “\r”, “\n”

String[] strArray = aString.split("\\s+");

6、substring()方法究竟是什么？

在jdk 6中，substring()方法在原来字符串中提供了一个截取字符的窗口，它并没有创建一个新的String实例。如果你想创建新的字符数组，你可以在substring()后加一个空字符，就像这样：

str.substring(m, n) + ""

这样就会创建一个新的String实例，上面的方法有时候可以让你的程序运行速度更快，因为垃圾回收器可以将没用的大字符串回收走，并保留其子字符串。

7、String、StringBuilder和StringBuffer哪个更优？

String和StringBuilder：StringBuilder是可变的，也就是说用StringBuilder创建的字符串你可以随时改变它。StringBuilder和StringBuffer：StringBuffer是同步的，它是线程安全（thread-safe）的，但效率要比StringBuilder差得多。

8、如何重复输出字符串？

在Python中，我们只需要为字符串乘上一个数字就可以重复输出该字符串了。然而在Java中，我们可以用StringUtils的repeat()方法来实现，StringUtils是Apache公共语言库的其中一个类库成员。

String str = "abcd";String repeated = StringUtils.repeat(str,3);//abcdabcdabcd

9、如何将字符串转换成日期类型？

你可以按以下方法来做，代码如下：

String str = "Sep 17, 2013";Date date = new SimpleDateFormat("MMMM d, yy", Locale.ENGLISH).parse(str);
System.out.println(date);//Tue Sep 17 00:00:00 EDT 2013

10、如何统计指定字符在字符串中出现的频率

同样我们利用了Apache公共语言库中的StringUtils，代码如下：

int n = StringUtils.countMatches("11112222", "1");
System.out.println(n);

服务端 I/O 性能大比拼：Node、PHP、Java 和 Go

Sat, 14 Oct 2017 19:47:46 +0800

理解应用程序的输入/输出（I/O）模型，意味着其在计划处理负载与残酷的实际使用场景之间的差异。若应用程序比较小，也没有服务于很高的负载，也许它影响甚微。但随着应用程序的负载逐渐上涨，采用错误的I/O模型有可能会让你到处踩坑，伤痕累累。

正如大部分存在多种解决途径的场景一样，重点不在于哪一种途径更好，而是在于理解如何进行权衡。让我们来参观下I/O的景观，看下可以从中窃取点什么。

在这篇文章，我们将会结合Apache分别比较Node，Java，Go，和PHP，讨论这些不同的语言如何对他们的I/O进行建模，各个模型的优点和缺点，并得出一些初步基准的结论。如果关心你下一个Web应用的I/O性能，那你就找对文章了。

I/O基础知识：快速回顾

为了理解与I/O密切相关的因素，必须先来回顾在操作系统底层的概念。虽然不会直接处理这些概念的大部分，但通过应用程序的运行时环境你一直在间接地处理他们。而关键在于细节。

系统调用

首先，我们有系统调用，它可以描述成这样：

你的程序（在“用户区域”，正如他们所说的）必须让操作系统内核在它自身执行I/O操作。
“系统调用”（syscall）意味着你的程序要求内核做某事。不同的操作系统，实现系统调用的细节有所不同，但基本的概念是一样的。这将会有一些特定的指令，把控制权从你的程序转交到内核（类似函数调用但有一些专门用于处理这种场景的特殊sauce）。通常来说，系统调用是阻塞的，意味着你的程序需要等待内核返回到你的代码。
内核在我们所说的物理设备（硬盘、网卡等）上执行底层的I/O操作，并回复给系统调用。在现实世界中，内核可能需要做很多事情才能完成你的请求，包括等待设备准备就绪，更新它的内部状态等，但作为一名应用程序开发人员，你可以不用关心这些。以下是内核的工作情况。

阻塞调用与非阻塞调用

好了，我刚刚在上面说系统调用是阻塞的，通常来说这是对的。然而，有些调用被分类为“非阻塞”，意味着内核接收了你的请求后，把它放进了队列或者缓冲的某个地方，然后立即返回而并没有等待实际的I/O调用。所以它只是“阻塞”了一段非常短的时间，短到只是把你的请求入列而已。

这里有一些有助于解释清楚的（Linux系统调用）例子：-read()是阻塞调用——你传给它一个文件句柄和一个存放所读到数据的缓冲，然后此调用会在当数据好后返回。注意这种方式有着优雅和简单的优点。-epoll_create()，epoll_ctl()，和epoll_wait()这些调用分别是，让你创建一组用于侦听的句柄，从该组添加/删除句柄，和然后直到有活动时才阻塞。这使得你可以通过一个线程有效地控制一系列I/O操作。如果需要这些功能，这非常棒，但也正如你所看到的，使用起来当然也相当复杂。

理解这里分时差异的数量级是很重要的。如果一个CPU内核运行在3GHz，在没有优化的情况下，它每秒执行30亿次循环（或者每纳秒3次循环）。非阻塞系统调用可能需要10纳秒这样数量级的周期才能完成——或者“相对较少的纳秒”。对于正在通过网络接收信息的阻塞调用可能需要更多的时间——例如200毫秒（0.2秒）。例如，假设非阻塞调用消耗了20纳秒，那么阻塞调用消耗了200,000,000纳秒。对于阻塞调用，你的程序多等待了1000万倍的时间。

内核提供了阻塞I/O（“从网络连接中读取并把数据给我”）和非阻塞I/O（“当这些网络连接有新数据时就告诉我”）这两种方法。而使用何种机制，对应调用过程的阻塞时间明显长度不同。

调度

接下来第三件关键的事情是，当有大量线程或进程开始阻塞时怎么办。

出于我们的目的，线程和进程之间没有太大的区别。实际上，最显而易见的执行相关的区别是，线程共享相同的内存，而每个进程则拥有他们独自的内存空间，使得分离的进程往往占据了大量的内存。但当我们讨论调度时，它最终可归结为一个事件清单（线程和进程类似），其中每个事件需要在有效的CPU内核上获得一片执行时间。如果你有300个线程正在运行并且运行在8核上，那么你得通过每个内核运行一段很短的时间然后切换到下一个线程的方式，把这些时间划分开来以便每个线程都能获得它的分时。这是通过“上下文切换”来实现的，使得CPU可以从正在运行的某个线程/进程切换到下一个。

这些上下文切换有一定的成本——它们消耗了一些时间。在快的时候，可能少于100纳秒，但是根据实现的细节，处理器速度/架构，CPU缓存等，消耗1000纳秒甚至更长的时间也并不罕见。

线程（或者进程）越多，上下文切换就越多。当我们谈论成千上万的线程，并且每一次切换需要数百纳秒时，速度将会变得非常慢。

然而，非阻塞调用本质上是告诉内核“当你有一些新的数据或者这些连接中的任意一个有事件时才调用我”。这些非阻塞调用设计于高效地处理大量的I/O负载，以及减少上下文切换。

到目前为止你还在看这篇文章吗？因为现在来到了有趣的部分：让我们来看下一些流利的语言如何使用这些工具，并就在易用性和性能之间的权衡作出一些结论……以及其他有趣的点评。

请注意，虽然在这篇文章中展示的示例是琐碎的（并且是不完整的，只是显示了相关部分的代码），但数据库访问，外部缓存系统（memcache等全部）和需要I/O的任何东西，都以执行某些背后的I/O操作而结束，这些和展示的示例一样有着同样的影响。同样地，对于I/O被描述为“阻塞”（PHP，Java）这样的情节，HTTP请求与响应的读取与写入本身是阻塞的调用：再一次，更多隐藏在系统中的I/O及其伴随的性能问题需要考虑。

为项目选择编程语言要考虑的因素有很多。当你只考虑性能时，要考虑的因素甚至有更多。但是，如果你关注的是程序主要受限于I/O，如果I/O性能对于你的项目至关重要，那这些都是你需要了解的。“保持简单”的方法：PHP。

回到90年代的时候，很多人穿着匡威鞋，用Perl写着CGI脚本。随后出现了PHP，很多人喜欢使用它，它使得制作动态网页更为容易。

PHP使用的模型相当简单。虽然有一些变化，但基本上PHP服务器看起来像：

HTTP请求来自用户的浏览器，并且访问了你的Apache网站服务器。Apache为每个请求创建一个单独的进程，通过一些优化来重用它们，以便最大程度地减少其需要执行的次数（创建进程相对来说较慢）。Apache调用PHP并告诉它在磁盘上运行相应的.php文件。PHP代码执行并做一些阻塞的I/O调用。若在PHP中调用了file_get_contents()，那在背后它会触发read()系统调用并等待结果返回。

当然，实际的代码只是简单地嵌在你的页面中，并且操作是阻塞的：

关于它如何与系统集成，就像这样：

相当简单：一个请求，一个进程。I/O是阻塞的。优点是什么呢？简单，可行。那缺点是什么呢？同时与20,000个客户端连接，你的服务器就挂了。由于内核提供的用于处理大容量I/O（epoll等）的工具没有被使用，所以这种方法不能很好地扩展。更糟糕的是，为每个请求运行一个单独的过程往往会使用大量的系统资源，尤其是内存，这通常是在这样的场景中遇到的第一件事情。

注意：Ruby使用的方法与PHP非常相似，在广泛而普遍的方式下，我们可以将其视为是相同的。

多线程的方式：Java

所以就在你买了你的第一个域名的时候，Java来了，并且在一个句子之后随便说一句“dot com”是很酷的。而Java具有语言内置的多线程（特别是在创建时），这一点非常棒。

大多数Java网站服务器通过为每个进来的请求启动一个新的执行线程，然后在该线程中最终调用作为应用程序开发人员的你所编写的函数。

在Java的Servlet中执行I/O操作，往往看起来像是这样：

由于我们上面的doGet方法对应于一个请求并且在自己的线程中运行，而不是每次请求都对应需要有自己专属内存的单独进程，所以我们会有一个单独的线程。这样会有一些不错的优点，例如可以在线程之间共享状态、共享缓存的数据等，因为它们可以相互访问各自的内存，但是它如何与调度进行交互的影响，仍然与前面PHP例子中所做的内容几乎一模一样。每个请求都会产生一个新的线程，而在这个线程中的各种I/O操作会一直阻塞，直到这个请求被完全处理为止。为了最小化创建和销毁它们的成本，线程会被汇集在一起，但是依然，有成千上万个连接就意味着成千上万个线程，这对于调度器是不利的。

Kotlin 将超越 Java 成为 Android 开发的第一语言？

Sat, 14 Oct 2017 00:08:50 +0800

Realm 公司提供了一款备受移动开发者欢迎的实时数据库，在调查了大约十万名活跃的开发者后，Realm 发现在今年 5 月份谷歌 I/O 大会之前用 Java 编写的 Android 应用中有 20% 正在用 Kotlin 进行重写。

根据调查数据，Realm 表示到 2018 年底，在 Android 开发领域，Kotlin 将超越 Java，成为开发 Android 应用的第一语言。

该公司于周二在官网上公布了其调查结果，它的惯例是每季度发布一次调查结果。

当然，这些数据不是特别适用于广泛的 Java 开发者群体，甲骨文最近估计这个群体有 1200 万人。不过数据表明，Android 生态系统确实处于迅速变化之中。

Kotlin 是一门面向 Java 虚拟机(JVM)、Android、JavaScript 和 Native 的开源语言，它于 2011 年由 JetBrains 推出，去年发布 1.0 版本，今年谷歌宣布它成为 Android 领域官方支持的开发语言。

JetBrains 表示，Kotlin 比 Java 更简洁，所需编写的代码行大概比 Java 少 40%。此外，类型安全方面 Kotlin 也比 Java 好，并支持函数式编程。

Realm 的数据显示，2016年9月，Kotlin 占 Android 开发的 5.1％，而 Java 的占 94.9％。一年之后，这个比例变成 Kotlin 升至 14.3％，而 Java 则降为 85.7％。这个变化相当大。

JVM 语言的兴衰史

Thu, 12 Oct 2017 23:38:25 +0800

不管什么时候，都会有一些预测 Java 覆灭的帖子出现。但有趣的是，这些帖子从不写预言成真的日期。说实话，它们说的都算正确，因为这是每一种语言的最终命运都是：覆灭湮没，准确地说是越来越少地被利用到新项目中。问题是：最后谁会取代它们呢？

上周我们在 InfoQ 一篇同样类型的文章。至少，这篇文章说出来这个语言可能的替代者 Kotlin。这让我对 JVM 的语言现状和趋势有了许多思考：注意，语言的趋势与每个语言的技术优点和缺点无关。

我于 2001 年年底开始做 Java 开发，当时，Java 是真的很酷。每一个新开发者都想使用所谓的新技术：无论是 .NET 还是 Java，而有经验一些的开发者使用的是 COBOL。我在学校学习了 C 和 C++，所以 Java 内存管理对于我来说非常简单。我对 Java 很满意，但并不是每个人都这么认为。

Groovy 诞生于 2003 年。但我不记得我是什么时候开始学习它的。而实际上：使用它后我不再需要一门脚本语言了。在具有多个开发团队并长时间开发企业级应用程序的背景之下，静态类型相比动态类型拥有巨大优势。尤其在进行产品测试以检查类型系统时。我唯一需要创建脚本的时候，是作为 WebSphere 管理员时：选择 Python 还是 TCL。

一年之后，Scala在2004年被我接受。我不记得是什么时候以及是怎样知道Scala的，但那时候确实是很晚了。与Groovy相反，我决定试试它。主要的理由是我长期以来对创建“更好”的代码（更好的可读性和可维护性）感兴趣。Scala是静态类型的，它更像我正在寻找的东西。我报了Coursera课程Scala中的函数式编程原理。它有三个主要的影响：

它让我质疑我写Java代码的方式。例如，为什么当我设计类时要自动生成getter和setter方法？

对大多数开发者来说，我觉得Scala很容易写出缺乏可读性的的代码——包括我。

我开始寻找其他替代语言。

在 Groovy 和 Scala 之后，第二代（如果你把 Java 也算做第一代的话，则是第三代）JVM 语言包括：

JetBrains Kotlin

Red Hat Ceylon

Eclipse eXtend

大致浏览一遍后，我确信他们没有太多的吸引力，不值得我投入时间。

几年前，我决定自学基本的 Android 开发，以便能够了解移动开发者的开发环境。好家伙，即使有多年开发 Java EE 和 Spring 应用程序的经验，但它还真给我一个惊喜了 - 还不是愉快的那种。这就像回到过去十年前那样的开发体验，Android API 非常低级，更别说在本地测试应用程序。经过快速的搜索相关信息，我发现 Kotlin 在很多地方被提到，所以最后决定试一试。我立即爱上 Kotlin 了，得亏它的扩展功能，我可以将现有的垃圾 API 改进得更好，甚至更优雅。我开始更多的挖掘这门语言，并开始在服务器端项目中使用 Kotlin。然后，Spring 框架宣布了与 Kotlin 的整合。然后在 Google I/O 大会上，Google 也宣布在 Android 开发中官方支持 Kotlin。

死磕 Java 并发：Java 内存模型之 happens-before

Tue, 10 Oct 2017 22:10:06 +0800

那么我们正确使用同步、锁的情况下，线程A修改了变量a何时对线程B可见？

我们无法就所有场景来规定某个线程修改的变量何时对其他线程可见，但是我们可以指定某些规则，这规则就是happens-before，从JDK 5 开始，JMM就使用happens-before的概念来阐述多线程之间的内存可见性。

在JMM中，如果一个操作执行的结果需要对另一个操作可见，那么这两个操作之间必须存在happens-before关系。

happens-before原则非常重要，它是判断数据是否存在竞争、线程是否安全的主要依据，依靠这个原则，我们解决在并发环境下两操作之间是否可能存在冲突的所有问题。下面我们就一个简单的例子稍微了解下happens-before ；

i = 1; //线程A执行

j = i ; //线程B执行

j 是否等于1呢？假定线程A的操作（i = 1）happens-before线程B的操作（j = i）,那么可以确定线程B执行后j = 1 一定成立，如果他们不存在happens-before原则，那么j = 1 不一定成立。这就是happens-before原则的威力。

happens-before原则定义如下：

如果一个操作happens-before另一个操作，那么第一个操作的执行结果将对第二个操作可见，而且第一个操作的执行顺序排在第二个操作之前。

两个操作之间存在happens-before关系，并不意味着一定要按照happens-before原则制定的顺序来执行。如果重排序之后的执行结果与按照happens-before关系来执行的结果一致，那么这种重排序并不非法。

下面是happens-before原则规则：

程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作；

锁定规则：一个unLock操作先行发生于后面对同一个锁额lock操作；

volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作；

传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C；

线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作；

线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生；

线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行；

对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始；

我们来详细看看上面每条规则（摘自《深入理解Java虚拟机第12章》）：

程序次序规则：一段代码在单线程中执行的结果是有序的。注意是执行结果，因为虚拟机、处理器会对指令进行重排序（重排序后面会详细介绍）。虽然重排序了，但是并不会影响程序的执行结果，所以程序最终执行的结果与顺序执行的结果是一致的。故而这个规则只对单线程有效，在多线程环境下无法保证正确性。

锁定规则：这个规则比较好理解，无论是在单线程环境还是多线程环境，一个锁处于被锁定状态，那么必须先执行unlock操作后面才能进行lock操作。

volatile变量规则：这是一条比较重要的规则，它标志着volatile保证了线程可见性。通俗点讲就是如果一个线程先去写一个volatile变量，然后一个线程去读这个变量，那么这个写操作一定是happens-before读操作的。

传递规则：提现了happens-before原则具有传递性，即A happens-before B , B happens-before C，那么A happens-before C

Java知识点归纳-J2EE 、 Web 部分

Mon, 09 Oct 2017 22:07:37 +0800

J2EE（Java2 Enterprise Edition）刚出现时一般会用于开发企业内部的应用系统，特别是web应用，所以渐渐，有些人就会把J2EE和web模式画上了等号。但是其实 J2EE 里面并不仅仅是web，可以看到很多其中的规范都是通用的，目的是为了高效开发出健壮的服务企业业务模式的应用系统。J2EE中也是可以没有web界面的应用，而现在面向大众用户开发的网站往往也会使用到很多的J2EE的技术，所以J2EE和web开发的概念都是融合在了一起了。

笔者在JAVA开发刚入行的时候，也是做了不少web相关的项目，之后渐渐地web使用比较少了，现在web开发的技术日新月异，不过一些基础知识还是类似，所以也把这部分内容稍作整理，以期望可以给大家一些经验。

这次主要涉及到的两大块内容: Web相关的， J2EE相关的技术

Web部分:

脱离开各种语言，纯粹和 web相关的就是这些: HTML，CSS，JavaScript。哪怕你不用Java开发，用C#、PHP或者Python，这些内容都是通用，这里主要偏重一些基础知识。

HTTP协议，HTTPS协议

我觉得做Web开发，HTTP是基础中的基础。在一开始的时候，开发者可能对于这个内容了解不是非常深入，只是有个初步的概念，这个没有问题，可以先从了解，简单使用开始。不过一旦有了一些web开发经验之后，你就需要把这块内容深入理解吃透。只知道简单概念，没有深入了解，可能并不会影响你开始上手做web开发，但是一旦涉及到一些性能调优、系统架构等工作，就需要你对HTTP有一个深入的了解，才能把工作做好。

对于HTTP请求，我主要会关注以下内容:

HTTP请求的模式: request/response

HTTP请求的方法：GET， POST， PUT，DELETE 等等

协议的具体格式: head + body

协议的各类返回码:1XX，2XX，3XX，4XX，5XX

Header中一些主要属性的含义和使用场景

HTTPS协议

Cookie的基本原理和使用场景

HTML， CSS

这是WEB开发的一个基础，如果公司有专门的前端开发人员，可能你就不需要做这块相关的内容。可能只需要准备一些服务，可以提供一些数据就行。不过要是公司没有专门的前端人员，那就需要你自己写简单的页面和简单的布局了。这种情况下，还是对HTML和CSS必须有个简单的了解才行。

HTML简单了解的话需要知道页面的结构，具体各个表单，标签的使用方法，CSS需要知道一些基本的选择器的编写和使用。但这也只能满足一些简单页面的要求。如果有更加复杂页面的开发需求，那对CSS+DIV的使用需要有更加深入的了解了，具体内容因为自己对这方面涉及不多，也不多说了，大家可以再找其他的参考资料。

JavaScript：

前端开发的语言，唯一的语言，就是JS。并且从中衍生出一个很优秀的框架jQuery。现在前端基本上只要有一点复杂度的，都会使用这两种技术。并且以jquery为基础，还有一些其他前台框架，提供了各种动态效果，还有表格，表单等一些常用的处理。近两年，AngularJS框架又开始火热起来，这个框架在前端实现了MVC的架构，给前端的开发带来了革命性的影响(但是不意味着所有的前端开发都应该要用这个)。这些都是很值得好好看一下。即便不是专攻前端开发的，但是对于这几个技术点，能够先了解一下基本情况，基本的原理，对于web开发来说，还是大有好处的。

Webservice

在现在的企业应用开发中，Webservice已经是个必备的工具了。在各个企业中，经过一段时间积累，会有很多不同种类的应用，这些应用可能都会使用不同的语言开发，并且需要相互之间的通讯。通讯的首选就是Webservice。前后台的交互，服务之间的交互，或者不同语言之间的交互，都可以使用Webservice这个技术。

Webservice的实现方式多种多样，两者共同点是大家都是以HTTP协议为基础的，都可以跨域，跨语言进行访问。

用的比较多的，一个是SOAP协议的方式。这是比较传统的webservice 的实现，这个协议比较重量级，发布者会将webservice以wsdl形式发布，调用者通过wsdl可以直接生成实体类等。对于调用者来说，“调用”这个步骤会更容易处理一些。不过SOAP形式也存在着消息量大，传输效率低等缺陷。SOAP协议本身的可选项比较多，比较复杂，各个属性设置略有差异会导致服务通讯的失败，需要在调试中需要花费更多的时间。

现在更加流行的是使用RESTFUL的Webservice。这种技术是简化了URL，或者说对URL做了一定格式的限定，同时配合上HTTP的各种method，包括有GET，POST，DELTE，PUT 等，来实现整体service的各种功能。一般传输的内容都是json格式的字符串。Restful的Webservice的优点在于这是一种更加轻量级的使用方式，传输效率更高，接口约定更加清晰，双方调试也会更加便利一些。缺点在于，json格式太灵活，所以双方都需要自行处理json中的各个参数。对于接口实体类的处理需要更多的逻辑和代码。

J2EE部分

JDBC(可以在J2SE中使用)

JDBC用于java和数据库交互。它是Java面向接口编程的一个典型实例：开发者使用JDBC的API进行开发，但是底层可以针对不同的数据库使用不同的JDBC驱动(由各个数据库供应商提供)。JDBC被归为了J2EE的规范中，但是在一般的java程序中也可以使用，而且也是几乎都会被直接或者间接使用（除非不用数据库）。这从侧面也说明了，其实J2EE企业开发和web开发并不是同一个概念，而是相互融合的。

JDBC是Java中最原始，最纯粹，效率最高的访问数据库的方式，我们熟知的hibernate、 Mybatis等ORM框架都是在JDBC基础上做的封装。了解JDBC对于以后和数据库更好打交道会有着很大的用处。哪怕是一个java开发新手，你需要去学习Hibernate、Mybatis等框架，你也需要先学习JDBC作为这些的基础。

对于JDBC的具体怎么实现，这个真不需要了解到那么深入。我推荐大家学习JDBC至少需要掌握以下内容：

1.JDBC的原理: JDBC为接口，可以有不同的驱动driver类

2.JDBC中的一些基本概念: connection， statement， resultset 等

3.JDBC使用的基本流程

Java总结篇系列：Java泛型

Sun, 08 Oct 2017 20:14:45 +0800

首先，我们看下下面这段简短的代码:

public class GenericTest { public static void main(String[] args) {

List list = new ArrayList();

list.add("qqyumidi");

list.add("corn");

list.add(100); for (int i = 0; i < list.size(); i++) {

String name = (String) list.get(i); // 1

System.out.println("name:" + name);

}

Java面试常被问到的题目+解答

Thu, 05 Oct 2017 21:24:02 +0800

摘要：第一，anonymousinnerclass(匿名内部类)是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)? 不行,对于匿名内部类,看到的一句话说的很到位: new <类或接口> <类的主体> 这种形式的new语句声明一个新的匿名类，他对一个给定的类进行扩展，或实现一个给定的接口。

第一，anonymousinnerclass(匿名内部类)是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?

不行,对于匿名内部类,看到的一句话说的很到位:

new <类或接口> <类的主体>

这种形式的new语句声明一个新的匿名类，他对一个给定的类进行扩展，或实现一个给定的接口。他还创建那个类的一个新实例，并把他作为语句的结果而返回。

这就是匿名类的实质,它本身就是一个类的继承或一个接口的实现,所以继承其它类或借口是无意义的.在eclipse中冶证实了我的想法.无论是继承其它类还是实现其它借口都显示Syntax error on token。

第二，staticnestedclass和innerclass的不同，说得越多越好(面试题有的很笼统)。

static nested class 指静态嵌套类,或称嵌套类,是C++中常用的说法,inner class指内部类,是JAVA中的说法。

内部类是一个类内部类的统称,具体分为四种：成员类,静态成员类，局部类，匿名类。其中匿名类是局部类的特殊情况。对于成员类和静态成员类都存在于类的顶层代码中。相当于类的静态方法和非静态方法的关系。区别在于成员类依赖于类实例而静态成员类不依赖。所以前者只能访问实例方法和成员而后者只能访问静态方法和成员。它们都用于创建一个只和当前类有关。和其它类无关的依赖类.是否静态取决于是否依赖类的实例。局部类相当于局部变量。存在于类的局部代码中。相当于在main()中随意定义和使用类。唯一的不同是它只能使用final型的局部变量。这和垃圾回收机制有关。即局部变量会在代码块结束后被回收。而对象不一定。所以对象只能使用final的局部变量。同样，局部类存在的局部代码块也可以有静态和非静态的差别。局部类罪常见的应用就是匿名类。匿名类就是无名子的局部类。常在SWING设计中的添加监听中出现。

static nested class相当于inner class中的静态成员类。

第三，&和&&的区别。

这个问得很少。

&和^,<<,<<<,|同属于位运算符,其中&是按位与,例如,1&1=1，1&0=0，&&是逻辑运算符,处理真假值，例如,true&&true=true。

如果你想学习Java可以来这个群，首先是二二零，中间是142，最后是906，里面可以学习和交流，也有资料可以下载。

第四，hashmap和hashtable的区别。

常问。

hashmap可以看做是hashtable的替代者，HashMap的Value和Key都可为NULL，而HashTable不可以，同时，HashTable是线程同步的，而HashMap不是.HashTable用Iterator遍历，HashMap用Enumeration遍历。HashTable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。计算index的方法不同，HashTable直接利用hashcode()得出，HashMap对hashcode重新计算得出。

第五，collection和collections的区别。

你千万别说一个是单数一个是复数。

collection是结合类的上级接口，子接口有List和Set等，Collections是java.util下的一个工具类，提供一些列静态方法对集合搜索排序线程同步化等。

第六，什么时候用assert。

api级的技术人员有可能会问这个。

在调试和优化中使用，用于判断逻辑表达式真假,若为假，终止程序并返回异常.assert比if的优点在于可以选择是否开启assert检查，也就是说assert产生的测试代码可以在正式发布时候选择忽略，这带来极大便利，默认assert检查是关闭的。此外，Junit相比assert来说，有着相似但更强大的测试能力。

第七，gc是什么?为什么要有gc?

基础。

GC 即 garbage collection(垃圾收集)，是JAVA用于回收内存的一种方式，主要的实现方法有引用计数，标记回收，复制清除等，GC可以避免内存泄露和堆栈溢出，有效提高内存的利用效率，同时将程序员从繁琐的内存管理中释放出来。

第八，string s=new string("xyz");创建了几个stringobject?

Java 中的异常和处理详解

Tue, 03 Oct 2017 19:16:17 +0800

简介

程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常。异常发生时，是任程序自生自灭，立刻退出终止，还是输出错误给用户？或者用C语言风格：用函数返回值作为执行状态？。

Java提供了更加优秀的解决办法：异常处理机制。

异常处理机制能让程序在异常发生时，按照代码的预先设定的异常处理逻辑，针对性地处理异常，让程序尽最大可能恢复正常并继续执行，且保持代码的清晰。

Java中的异常可以是函数中的语句执行时引发的，也可以是程序员通过throw 语句手动抛出的，只要在Java程序中产生了异常，就会用一个对应类型的异常对象来封装异常，JRE就会试图寻找异常处理程序来处理异常。

Throwable类是Java异常类型的顶层父类，一个对象只有是 Throwable 类的（直接或者间接）实例，他才是一个异常对象，才能被异常处理机制识别。JDK中内建了一些常用的异常类，我们也可以自定义异常。

Java异常的分类和类结构图

Java标准裤内建了一些通用的异常，这些类以Throwable为顶层父类。

Throwable又派生出Error类和Exception类。

错误：Error类以及他的子类的实例，代表了JVM本身的错误。错误不能被程序员通过代码处理，Error很少出现。因此，程序员应该关注Exception为父类的分支下的各种异常类。

异常：Exception以及他的子类，代表程序运行时发送的各种不期望发生的事件。可以被Java异常处理机制使用，是异常处理的核心。

总体上我们根据Javac对异常的处理要求，将异常类分为2类。

非检查异常（unckecked exception）：Error 和 RuntimeException 以及他们的子类。javac在编译时，不会提示和发现这样的异常，不要求在程序处理这些异常。所以如果愿意，我们可以编写代码处理（使用try…catch…finally）这样的异常，也可以不处理。对于这些异常，我们应该修正代码，而不是去通过异常处理器处理。这样的异常发生的原因多半是代码写的有问题。如除0错误ArithmeticException，错误的强制类型转换错误ClassCastException，数组索引越界ArrayIndexOutOfBoundsException，使用了空对象NullPointerException等等。

检查异常（checked exception）：除了Error 和 RuntimeException的其它异常。javac强制要求程序员为这样的异常做预备处理工作（使用try…catch…finally或者throws）。在方法中要么用try-catch语句捕获它并处理，要么用throws子句声明抛出它，否则编译不会通过。这样的异常一般是由程序的运行环境导致的。因为程序可能被运行在各种未知的环境下，而程序员无法干预用户如何使用他编写的程序，于是程序员就应该为这样的异常时刻准备着。如SQLException , IOException,ClassNotFoundException 等。

需要明确的是：检查和非检查是对于javac来说的，这样就很好理解和区分了。

初识异常

下面的代码会演示2个异常类型：ArithmeticException 和 InputMismatchException。前者由于整数除0引发，后者是输入的数据不能被转换为int类型引发。

package com.example;
import java. util .Scanner ;
public class AllDemo
{
public static void main (String [] args )

Java序列化的几种方式以及序列化的作用

Mon, 02 Oct 2017 20:40:10 +0800

一.Java序列化的作用

有的时候我们想要把一个Java对象变成字节流的形式传出去，有的时候我们想要从一个字节流中恢复一个Java对象。例如，有的时候我们想要

把一个Java对象写入到硬盘或者传输到网路上面的其它计算机，这时我们就需要自己去通过java把相应的对象写成转换成字节流。对于这种通用

的操作，我们为什么不使用统一的格式呢？没错，这里就出现了java的序列化的概念。在Java的OutputStream类下面的子类ObjectOutput-

Stream类就有对应的WriteObject(Object object) 其中要求对应的object实现了java的序列化的接口。

为了更好的理解java序列化的应用，我举两个自己在开发项目中遇到的例子:

1)在使用tomcat开发JavaEE相关项目的时候，我们关闭tomcat后，相应的session中的对象就存储在了硬盘上，如果我们想要在tomcat重启的

时候能够从tomcat上面读取对应session中的内容，那么保存在session中的内容就必须实现相关的序列化操作。

2)如果我们使用的java对象要在分布式中使用或者在rmi远程调用的网络中使用的话，那么相关的对象必须实现java序列化接口。

亲爱的小伙伴，大概你已经了解了java序列化相关的作用，接下来们来看看如何实现java的序列化吧。~

二.实现java对象的序列化和反序列化。

Java对象的序列化有两种方式。

a.是相应的对象实现了序列化接口Serializable，这个使用的比较多，对于序列化接口Serializable接口是一个空的接口，它的主要作用就是

标识这个对象时可序列化的，jre对象在传输对象的时候会进行相关的封装。这里就不做过多的介绍了。

下面是一个实现序列化接口的Java序列化的例子:非常简单

package com.shop.domain;import java.util.Date;public class Article implements java.io.Serializable {    private static final long serialVersionUID = 1L;    private Integer id;     private String title;  //文章标题    private String content;  // 文章内容    private String faceIcon;//表情图标    private Date postTime; //文章发表的时间    private String ipAddr;  //用户的ip    private User author;  //回复的用户    public Integer getId() {        return id;    }    public void setId(Integer id) {        this.id = id;    }    public String getTitle() {        return title;    }    public void setTitle(String title) {        this.title = title;    }    public String getContent() {        return content;    }    public void setContent(String content) {        this.content = content;    }    public String getFaceIcon() {        return faceIcon;    }    public void setFaceIcon(String faceIcon) {        this.faceIcon = faceIcon;    }    public Date getPostTime() {        return postTime;    }    public void setPostTime(Date postTime) {        this.postTime = postTime;    }    public User getAuthor() {        return author;    }    public void setAuthor(User author) {        this.author = author;    }    public String getIpAddr() {        return ipAddr;    }    public void setIpAddr(String ipAddr) {        this.ipAddr = ipAddr;    }}

b.实现序列化的第二种方式为实现接口Externalizable，Externlizable的部分源代码如下:

Java 和 JavaScript 的关系！

Fri, 29 Sep 2017 20:28:20 +0800

58的姚总曾出现这么个尴尬事

强行装逼失败

这 JavaScript 和 Java 有啥区别

据说还有很多人不知道

于是，猿妹找了一堆形象生动的解答

来给大家科普一下两者区别！！

答案有这样的

↓↓↓

这样的

↓↓↓

最形象当属这样的

为什么Java程序员薪资一直居高不下？

Thu, 28 Sep 2017 21:05:35 +0800

众所周知，目前互联网行业是众多行业中薪资待遇最好的，包括程序员、运营、新媒体和这个行业周边的商务、销售等人员的工资，都是其他行业所不能比拟的。本文就为大家分析一下Java程序员薪资居高不下的原因。

程序员问科比：你为什么这么成功?

科比：你知道洛杉矶凌晨4点的样子吗?

程序员：不知道，不过我知道凌晨4点的北京，一般那时候我还没睡，怎么了?

科比：没，没什么……

上面的段子说明了程序员加班的程度，有的人看到这一点就明了了。但这不是唯一的原因。

曾经看过一个等式：热门+门槛高=高工资，那么我们就从门槛开始分析原因。

1. Java程序员的门槛相对比较高

首先要计算机技术或是相关专业的大学生，原因有二，一是，Java对从业人员素质有一点要求，计算机相关行业会了解最基本的互联网的相关知识，以及简单的语言基础；二是，从事这一行业，招聘公司对学历有要求，最起码要是专科以上的。

当然，也不排除有非计算机专业的从事Java行业的人，但是万事开头难，很多人抱着很大的希望去学习，随着遇到的困难越来越多，慢慢的也就放弃了，因此有一部分人都倒在了入门的路上。所以干这一行的人相对其他行业还是少。

2. Java行业市场需求存在巨大的缺口

这几年中国在移动互联网这块发展非常迅猛，各种创业公司、小团队如雨后春笋般冒出来，对Java开发的需要变大。但存在人才发展跟不上市场的需求的现状，相对应的给优秀Java人才开出的薪资待遇随之水涨船高。

3. 程序员的确很辛苦，需要不断学习、进步

辛苦分劳力和脑力两种，劳力工作不难，每天重复着体力活；但脑力活就不一样了，程序员一辈子都在学习、在挑战，因为这是一个不进步就out的行业。

随着互联网的发展，很多企业随着业务发展要求服务器程序更稳定，更可靠。如：京东，淘宝等大型人网站均采用Java框架进行开发。银行券商等机构均采用Java作为开发语言。

对于在职的Java从业人员来讲，不断的努力吸收新的知识，跟上互联网进步的节奏是很重要的。

开发人员需要掌握的英文词汇，必须要学会的

Wed, 27 Sep 2017 11:59:42 +0800

当年学习Java时想过，英语不好或者一窍不通，能不能学好Java开发；就这个问题请教了开发前辈，答案是不懂英文也可以学好Java，但必须要学会一些常用英文词汇，必竟Java是英文开发创造的，以下整理了开发中常用的词汇及中文含义；当然知道这些远远不够，我们可以在学习工作过程中慢慢积累，渐渐会发现原来学会了这么多英文，好了，开始学习吧

我以英文首字母进行排序：

1、Abstract class 抽象类:抽象类是不允许实例化的类，因此一般它需要被进行扩展继承。

2、Abstract method 抽象方法:抽象方法即不包含任何功能代码的方法。

3、Anonymous class 匿名类:当你需要创建和使用一个类，而又不需要给出它的名字或者再次使用的使用，就可以利用匿

名类。

4、Anonymous inner classes 匿名内部类:匿名内部类是没有类名的局部内部类。

5、API 应用程序接口:提供特定功能的一组相关的类和方法的集合。

6、Array 数组:存储一个或者多个相同数据类型的数据结构，使用下标来访问。在Java中作为对象处理。

7、Base class 基类:即被扩展继承的类。

8、Call stack 调用堆栈:调用堆栈是一个方法列表，按调用顺序保存所有在运行期被调用的方法。

9、Casting 类型转换 :即一个类型到另一个类型的转换，可以是基本数据类型的转换，也可以是对象类型的转换。

10、Char 字符:容纳单字符的一种基本数据类型。

11、Child class 子类:见继承类Derived class

12、Class 类:面向对象中的最基本、最重要的定义类型。

13、Class members 类成员:定义在类一级的变量，包括实例变量和静态变量。

14、Class methods 类方法:类方法通常是指的静态方法，即不需要实例化类就可以直接访问使用的方法。

15、Class variable 类变量:见静态变量Static variable

16、Collection 容器类:容器类可以看作是一种可以储存其他对象的对象，常见的容器类有Hashtables和Vectors。

17、Collection interface 容器类接口:容器类接口定义了一个对所有容器类的公共接口。

java邮件类---MailUtils 用户网站统一发送激活码

Mon, 25 Sep 2017 20:52:08 +0800

package cn.pyd.itcaststore.utils;

import java.net.Authenticator;
import java.net.PasswordAuthentication;
import java.util.Properties;

import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMessage.RecipientType;

public class MailUtils {
	public static void sendMail(String email,String emailMsg) throws AddressException,MessagingException{
		//1.创建Properties对象，并设置邮件服务器的基本信息
		Properties props=new Properties();
		//1.1设计邮件传输协议为SMIP
		 props.put("mail.smtp.host", "smtp.163.com");//存储发送邮件服务器的信息 
	 props.put("mail.smtp.auth", "true");//同时通过验证
	 props.setProperty("mail.transport.protocol", "smtp"); 
		//1.4创建验证器
		javax.mail.Authenticator auth=new javax.mail.Authenticator() {
			public javax.mail.PasswordAuthentication getPasswordAuthentication() {
				return new javax.mail.PasswordAuthentication("用户名", "密码");
			}
		};
		//实例化邮件会话Session
		Session session=Session.getInstance(props, auth);
		//2.创建一个Message，该对象相当于邮件内容
		Message message=new MimeMessage(session);
		//2.1设置发送者
		message.setFrom(new InternetAddress("用户名@163.com"));
		//2.2设置发送方式与接受者，邮件接受者在调用sendMail()方法时通过参数传递过来
		message.setRecipient(RecipientType.TO,new InternetAddress(email));
		//2.3设置邮件发送主题
		message.setSubject("用户激活");
		message.setContent(emailMsg, "text/html;charset=utf-8");
		//3.发送邮件
		Transport.send(message);
	}
}

学习Java需吃透这些基本概念你知道吗？

Sun, 24 Sep 2017 21:14:30 +0800

学习好比盖房子，打地基好很重要，房了能盖多高关键看地基；学习同样道理，基础知识是以后学习一切技术的必要条件，我们在准备学习一门开发语言时，首先要学习它的基础，不仅要会，更要融会贯通；万变不离其宗，无论技术框架怎么变，本质都是对基础的封装再造。

在以往的工作学习中，我总结了一些Java非常重要的知识点或者说基本概念，好了，进入正题：

1、面向对象编程（OOP）:OOP最重要的思想是类,类是模板,从类中构造一个对象,即创建了这个类的一个实例；

2、封装:是把数据和行为结合在一起，并对对象使用者隐藏数据的实现过程,通常一个对象中的数据叫他的实例字段(instance field) ；

3、继承:Java中允许在已经存在的类的基础上构建新的类,当你继承一个已经存在的类时,那么你就复用了这个类的方法和字段,同时你可以在新类中添加新的方法和字段；

4、多态:在java中,对象变量是多态的；需要注意的是java中不支持多重继承；

5、类之间的关系:

use-a :依赖关系；

has-a :聚合关系；

is-a : 继承关系–例:A类继承了B类,此时A类不仅有了B类的方法,还有其自己的方法；

6、构造对象使用构造器:构造器是一种特殊的方法,它的作用是构造对象并对其初始化，

构造器特点:构造器可以有0个,一个或多个参数；

构造器和类名称是相同的；

一个类可以有多个构造器；

构造器没有返回值；

构造器一定是和new运算符一起使用的；

7、包(package)：Java允许把一个或多个类放在一起成为一组,称作为包,以便于更好的管理,标准Java库分为许多包如java.lang、java.util、java,net等,包是分层次的，所有的java包都在java和javax包层次内；

8、重载:当多个方法具有相同的名字而含有不同的参数时,这时就发生了重载，编译器会选出调用哪个方法；

9、健壮特性:Java采取了一个安全指针模型,能有效防止重写内存和数据崩溃；

10、安全:Java可以用来构建防病毒和防攻击的系统，事实证明Java在防毒方面做的比较好；

11、可移植性:Java中对基本数据结构类型的大小和算法都有严格的规定，所以有很好的可移植性；

12、多线程:由于Java的机制，它处理多线程的过程很简单,Java把多线程实现交给底下操作系统或线程程序完成，所以多线程是Java作为服务器端开发语言的流行原因之一；

13、动态绑定:这是Java调用对象方法的机制；

14、Java中的每一个类都是从Object类扩展而来的；

15、内部类:一个内部类的定义是定义在另一个内部类中；

以上只列出了比较重要的，必须掌握的知识点。

书城注册登录servlet--UserService.java

Sat, 23 Sep 2017 21:03:03 +0800

package cn.itcast.itcaststore.service;
import java.sql.SQLException;
import java.util.Date;
import javax.security.auth.login.LoginException;
import cn.itcast.itcaststore.dao.UserDao;
import cn.itcast.itcaststore.domain.User;
import cn.itcast.itcaststore.exception.ActiveUserException;
import cn.itcast.itcaststore.exception.RegisterException;
import cn.itcast.itcaststore.utils.MailUtils;

public class UserService {
	private UserDao dao = new UserDao();
	// 注册操作
	public void register(User user) throws RegisterException {
		// 调用dao完成注册操作
		try {
			dao.addUser(user);
			// 发送激活邮件
			String emailMsg = "感谢您注册网上书城，点击"
					+ " 激活 后使用。"
							+ "
为保障您的账户安全，请在24小时内完成激活操作";
			MailUtils.sendMail(user.getEmail(), emailMsg);
		} catch (Exception e) {
			e.printStackTrace();
			throw new RegisterException("注冊失败");
		}
	}
	// 激活用户
	public void activeUser(String activeCode) throws ActiveUserException {
		try {
			// 根据激活码查找用户
			User user = dao.findUserByActiveCode(activeCode);
			if (user == null) {
				throw new ActiveUserException("激活用户失败");
			}
			// 判断激活码是否过期 24小时内激活有效.
			// 1.得到注册时间
			Date registTime = user.getRegistTime();
			// 2.判断是否超时
			long time = System.currentTimeMillis() - registTime.getTime();
			if (time / 1000 / 60 / 60 > 24) {
				throw new ActiveUserException("激活码过期");
			}
			// 激活用户，就是修改用户的state状态
			dao.activeUser(activeCode);
		} catch (SQLException e) {
			e.printStackTrace();
			throw new ActiveUserException("激活用户失败");
		}
	}
	// 登录操作
	public User login(String username, String password) throws LoginException {
		try {
			//根据登录时表单输入的用户名和密码，查找用户
			User user = dao.findUserByUsernameAndPassword(username, password);
			//如果找到，还需要确定用户是否为激活用户
			if (user != null) {
				// 只有是激活才能登录成功，否则提示“用户未激活”
				if (user.getState() == 1) {
					return user;
				}
				throw new LoginException("用户未激活");
			}
			throw new LoginException("用户名或密码错误");
		} catch (SQLException e) {
			e.printStackTrace();
			throw new LoginException("登录失败");
		}
	}
}

Java验证码的绘制

Fri, 22 Sep 2017 20:08:32 +0800

package cn.itcast.itcaststore.utils;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import javax.imageio.ImageIO;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
 * 生成验证码的工具类
 */
public class CheckImageServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
	// 集合中保存所有成语
	private List words = new ArrayList();
	@Override
	public void init() throws ServletException {
		// 初始化阶段，读取new_words.txt
		// web工程中读取文件，必须使用绝对磁盘路径
		String path = getServletContext().getRealPath("/WEB-INF/new_words.txt");
		try {
			BufferedReader reader = new BufferedReader(new InputStreamReader(
					new FileInputStream(path), "utf-8"));
			String line;
			while ((line = reader.readLine()) != null) {
				words.add(line);
			}
			reader.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		// 禁止缓存
		// response.setHeader("Cache-Control", "no-cache");
		// response.setHeader("Pragma", "no-cache");
		// response.setDateHeader("Expires", -1);
		int width = 180;
		int height = 30;
		// 步骤一 绘制一张内存中图片
		BufferedImage bufferedImage = new BufferedImage(width, height,
				BufferedImage.TYPE_INT_RGB);
		// 步骤二 图片绘制背景颜色 ---通过绘图对象
		Graphics graphics = bufferedImage.getGraphics();// 得到画图对象 --- 画笔
		// 绘制任何图形之前 都必须指定一个颜色
		graphics.setColor(getRandColor(200, 250));
		graphics.fillRect(0, 0, width, height);
		// 步骤三 绘制边框
		graphics.setColor(Color.WHITE);
		graphics.drawRect(0, 0, width - 1, height - 1);
		// 步骤四 四个随机数字
		Graphics2D graphics2d = (Graphics2D) graphics;
		// 设置输出字体
		graphics2d.setFont(new Font("宋体", Font.BOLD, 18));
		Random random = new Random();// 生成随机数
		int index = random.nextInt(words.size());
		String word = words.get(index-1);// 获得成语
		// 定义x坐标
		int x = 10;
		for (int i = 0; i < word.length(); i++) {
			// 随机颜色
			graphics2d.setColor(new Color(20 + random.nextInt(110), 20 + random
					.nextInt(110), 20 + random.nextInt(110)));
			// 旋转 -30 --- 30度
			int jiaodu = random.nextInt(60) - 30;
			// 换算弧度
			double theta = jiaodu * Math.PI / 180;
			// 获得字母数字
			char c = word.charAt(i);
			// 将c 输出到图片
			graphics2d.rotate(theta, x, 20);
			graphics2d.drawString(String.valueOf(c), x, 20);
			graphics2d.rotate(-theta, x, 20);
			x += 40;
		}
		// 将验证码内容保存session
		request.getSession().setAttribute("checkcode_session", word);
		// 步骤五 绘制干扰线
		graphics.setColor(getRandColor(160, 200));
		int x1;
		int x2;
		int y1;
		int y2;
		for (int i = 0; i < 30; i++) {
			x1 = random.nextInt(width);
			x2 = random.nextInt(12);
			y1 = random.nextInt(height);
			y2 = random.nextInt(12);
			graphics.drawLine(x1, y1, x1 + x2, x2 + y2);
		}
		// 将上面图片输出到浏览器 ImageIO
		graphics.dispose();// 释放资源
		ImageIO.write(bufferedImage, "jpg", response.getOutputStream());
	}
	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		doGet(request, response);
	}
	/**
	 * 取其某一范围的color
	 * @param fc int 范围参数1
	 * @param bc int 范围参数2
	 * @return Color
	 */
	private Color getRandColor(int fc, int bc) {
		// 取其随机颜色
		Random random = new Random();
		if (fc > 255) {
			fc = 255;
		}
		if (bc > 255) {
			bc = 255;
		}
		int r = fc + random.nextInt(bc - fc);
		int g = fc + random.nextInt(bc - fc);
		int b = fc + random.nextInt(bc - fc);
		return new Color(r, g, b);
	}
}

Java-Filter过滤器用于过滤整个项目的编码

Fri, 22 Sep 2017 20:00:54 +0800

整个分为实现类以及在web.xml文件中对编写的filter类进行注册

package cn.itcast.itcaststore.web.filter;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
/**
 * 编码过滤器（用于统一项目编码）
 */
public class EncodingFilter implements Filter {
	public void init(FilterConfig filterConfig) throws ServletException {
}
public void doFilter(ServletRequest request, ServletResponse response,
		FilterChain chain) throws IOException, ServletException {
	// 处理请求乱码
	HttpServletRequest httpServletRequest = (HttpServletRequest) request;
	HttpServletRequest myRequest = new MyRequest(httpServletRequest);
	// 处理响应乱码
	response.setContentType("text/html;charset=utf-8");
	chain.doFilter(myRequest, response);
}
public void destroy() {

}

}
// 自定义request对象
class MyRequest extends HttpServletRequestWrapper {
private HttpServletRequest request;
private boolean hasEncode;
public MyRequest(HttpServletRequest request) {
super(request);// super必须写
this.request = request;
}
// 对需要增强方法 进行覆盖
@SuppressWarnings({ “unchecked”, “rawtypes” })
@Override
public Map getParameterMap() {
// 先获得请求方式
String method = request.getMethod();
if (method.equalsIgnoreCase(“post”)) {
// post请求
try {
// 处理post乱码
request.setCharacterEncoding(“utf-8”);
return request.getParameterMap();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
} else if (method.equalsIgnoreCase(“get”)) {
// get请求
Map<string, string[]=""> parameterMap = request.getParameterMap();
if (!hasEncode) { // 确保get手动编码逻辑只运行一次
for (String parameterName : parameterMap.keySet()) {
String[] values = parameterMap.get(parameterName);
if (values != null) {
for (int i = 0; i < values.length; i++) {
try {
values[i] = new String(values[i].getBytes(“ISO-8859-1”),“utf-8”);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
}
}
hasEncode = true;
}
return parameterMap;
}
return super.getParameterMap();
}
@Override
public String getParameter(String name) {
@SuppressWarnings(“unchecked”)
Map<string, string[]=""> parameterMap = getParameterMap();
String[] values = parameterMap.get(name);
if (values == null) {
return null;
}
return values[0]; // 取回参数的第一个值
}
@Override
public String[] getParameterValues(String name) {
@SuppressWarnings(“unchecked”)
Map<string, string[]=""> parameterMap = getParameterMap();
String[] values = parameterMap.get(name);
return values;
}
}
</string,></string,></string,>

web.xml配置

Java项目实战经验—程序员成长的钥匙

Thu, 21 Sep 2017 22:23:27 +0800

Java就是用来做项目的！Java的主要应用领域就是企业级的项目开发！要想从事企业级的项目开发，你必须掌握如下要点：

1、掌握项目开发的基本步骤

2、具备极强的面向对象的分析与设计技巧

3、掌握用例驱动、以架构为核心的主流开发方法

关于基础知识：你可以看看这些名词或知识点，看是否能说出个一二三四来。

JavaSE

----基本语法、数据类型、操作符等：int、long、Integer、Long、if、else、for、while

----数组与集合：数组的定义和使用方法、Collection、List、Set、Map、ArrayList、HashSet、HashMap、Iterator、equals、hashCode、Comparable、Comparator

----常用类：String、intern、常量池、StringBuffer、java.util.Date、SimpleDateFormat、Regex（正则表达式）

----反射机制：Class、Method、Field、invoke、newInstance、BeanUtils（apache-commons）、PropertyUtils（apache-commons）

----输入输出流：InputStream、OutputStream、Reader、Writer、Adapter设计模式与原始流类、Decorator设计模式与包装流类、对象序列化和反序列化

----多线程：Thread、Runnable、sleep、wait、notify、synchronized、lock

Servlet和JSP

HTML与JavaScript

----你需要能够理解常见的网页标签、理解在网页中引入JavaScript的方法、以及JavaScript的基本语法与使用方法

接下来是SSH：

Struts2：

为什么每次请求都要创建一个Action对象？

ModelDriven拦截器的配置中refreshModelBeforeResult解决了什么问题？

为什么在web.xml中配置的StrutsPrepareAndExecuteFilter要过滤所有的请求？

请你给我谈谈ValueStack？

Struts2是如何实现MVC设计模式的？

Spring：

你为什么要用Spring？

请你聊一聊IOC/DI？

什么是声明式的事务管理？为什么要使用声明式的事务管理？Spring如何实现声明式的事务管理？

把spring和hibernate集成，定义事务管理特性的时候，为何要将除了添加、删除、更新操作之外的方法，即主要执行查询任务的方法定义为read-only？

Hibernate：

请你谈谈你对OR映射的理解？

很多人说Hibernate不适合大项目，性能有问题，你是如何理解的？

Hibernate为什么一定要定义一个数据库标识？

程序猿幽默你是学不来的！

Wed, 20 Sep 2017 20:47:51 +0800

1、程序员找不女朋友的原因

程序员问禅师：“大师,我身体健康,思想端正,各方面都不错，为何就是找不到女朋友呢?”

禅师浅笑,答：“原因很简单，不过若想我告诉你，你需先写一段java代码。”

青年略一沉吟，写完了。

“再写一段C#” 写完了，

“再写一段php” 写完了，

“再写一段js”，写完了，

“这就是原因” 。

2、技术宅男如何把妹？

1.自制系统盘内置马儿随时知道MM在做什么，计划任务定期搞崩系统从而保持用户粘性；

2.给MM推荐自制APP，随时知道mm位置给她惊喜；

3.经过一段时间你就积累了大量数据，做一下数据挖掘就知道她的一切喜好习惯；

4.将该应用免费开放给更多宅男，于是有了海量数据。

——这就是云把妹。

3、程序员如何制造就业机会

一老板坐飞机,旁边一刚毕业程序员拿着杂志看,一边看一边念叨:云计算要火?

老板听了,回去问VP:什么是云计算?

VP回去告诉总监:我们可能要做云计算;

总监回去告诉经理:公司要做云计算,马上招人.

经理面试,有一个就是前几天那个拿杂志的毕业生,

毕业生说,没想到云计算真的要火?

——所以机会还是给有准备的人。

4、世界上最没用的几句话

1、警察：不要跑！

2、国足：必胜！

3、老师：同学们不要睡了！

4、病人：医生，您轻点儿！

5、父母：孩子，不要闹了！

6、罪犯：我是冤枉啊！

7、女人：不要嘛！

8、男人：我发誓！

9、程序员：这个不能实现！

5、程序员找不到对象

java和JavaScript究竟是什么关系？

Sun, 17 Sep 2017 21:27:42 +0800

犹记得刚刚接触Java的时候，有一天突然看见了JavaScript，第一反应就是：这是什么?跟Java这么像，莫非它俩之间有什么不可告人的关系?

这就得从他们诞生时开始说起：

1994年的时候，网景公司(Netscape)发布了Navigator浏览器0.9版。这是历史上第一个比较成熟的网络浏览器，轰动一时。但是，这个版本的浏览器只能用来浏览，不具备与访问者互动的能力。因此，网景公司急需一种网页脚本语言，使得浏览器可以与网页互动。1995年Sun公司将Oak语言改名为Java，正式向市场推出，并且打出了“一次编写，到处运行(Write once，run anywhere)”的宣传口号。网景公司非常看好Java，决定与Sun公司结成联盟。仅一个月后，网景公司做出决定，未来的网页脚本语言，必须看上去与Java足够相似，但是比Java简单。程序员Brendan Eich被指定为这种“简化版Java语言”的设计师。

但是Brendan Eich对Java丝毫没有兴趣，用了10天时间就设计出了JavaScript。总体的设计思路是：(1)借鉴C语言的基本语法;(2)借鉴Java语言的数据类型和内存管理;(3)借鉴Scheme语言，将函数提升到“第一等公民”(first class)的地位;(4)借鉴Self语言，使用基于原型(prototype)的继承机制。也就是说，Java Script在设计时所参考的对象不包括 Java，而包括了像 Self 和 Scheme 这样的语言，它实际上是函数式编程和面向对象编程两种语言风格的混合产物。并且javascript最初的名字并不是javascript，而是LiveScript，名字中的“Java”是经过SUN Microsystems公司授权的。

简单说java和JavaScript是两个不同的语言。

1 语言特点：

1.1 弱类型：

JavaScript在变量声明的时候并不严格区分数据类型，(var 变量名)，不像java那样严格(类型：变量名)。也就说，Javascript面前一切平等，在他眼里大家都是人，而在java就有所不同，男人、女人、什么的……

基于这个特性，javascript在很多时候会都可以写的比java简洁，比如函数的声明等。

1.2 动态语言：

java在定义了一个数组的长度以后就不能再改变了，但是javascript却可以。并且java一个数组只能放同一种类型，但javascript可以在一个数组内加不同数据类型的数据。可以说Java比较死心眼，javascript则比较灵活。

1.3 脚本语言:

Java等后台语言都是编译后执行的，但是javascript却是边编译边执行。

2 数据类型

2.1 基础数据类型：

Java有八大数据类型：byte,short,intlong,float,double,char,Boolean。感觉javascript把上面的整理成了三种原始类型：number,string,boolean。另外还有两个特殊的原始类型是：null和undefined。

2.2 变量

Java：数据类型变量名=值;

Javascript：var 变量名=值;数组

Java：

类型[] 数组名=new 类型[数量];

类型[] 数组名=new 类型[]{元素1，元素2…};

Javascript：

var 数组名=[];

var 数组名=new Array();

3 函数：

Java：返回值类型函数名(类型参数1，类型参数2…){}

Javascript：function 函数名(参数1，参数2…){}

两者用途

java广泛应用于个人PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网等。

真正的Java学习从入门到精通，只需拿下这6点！

Sat, 16 Sep 2017 19:56:40 +0800

划重点
初入学习Java不知道该何从下手？
有了基础知识，提升技术不知该如何学习？
今天分享一个技能大篇，帮助你实现技术的提升，薪资的高涨，认真看哦！

一、工具篇JDK

JDK是整个Java的核心，包括了Java运行环境（Java Runtime Envirnment），一堆Java工具和Java基础的类库(rt.jar)。不论什么Java应用服务器实质都是内置了某个版本的JDK。因此掌握JDK是学好Java的第一步。最主流的JDK是Sun公司发布的JDK，除了Sun之外，还有很多公司和组织都开发了自己的JDK，例如IBM公司开发的JDK，BEA公司的Jrocket，还有GNU组织开发的JDK等等。其中IBM的JDK包含的JVM（Java Virtual Machine）运行效率要比Sun JDK包含的JVM高出许多。而专门运行在x86平台的Jrocket在服务端运行效率也要比Sun JDK好很多。但不管怎么说，我们还是需要先把Sun JDK掌握好。

1、 JDK的下载和安装

JDK又叫做J2SE（Java2 SDK Standard Edition），可以从Sun的Java网站上下载到，网页链接，JDK当前最新的版本是J2SDK1.4.2，建议下载该版本的JDK，下载页面在这里：网页链接。下载好的JDK是一个可执行安装程序，默认安装完毕后会在C:\Program Files\Java\目录下安装一套JRE（供浏览器来使用），在C:\j2sdk1.4.2下安装一套JDK（也包括一套JRE）。然后我们需要在环境变量PATH的最前面增加java的路径C:\j2sdk1.4.2\bin。这样JDK就安装好了。

2、 JDK的命令工具

JDK的最重要命令行工具：
java：启动JVM执行class
javac： Java编译器
jar： Java打包工具
javadoc： Java文档生成器

这些命令行必须要非常非常熟悉，对于每个参数都要很精通才行。对于这些命令的学习，JDK Documentation上有详细的文档。

【分享】Java并发面试题精选

Wed, 13 Sep 2017 20:20:01 +0800

1，什么是线程？

线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。

2，线程和进程有什么区别？

线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。每个线程都拥有单独的栈内存用来存储本地数据。

3，如何在Java中实现线程？

两种方式：java.lang.Thread 类的实例就是一个线程但是它需要调用java.lang.Runnable接口来执行，由于线程类本身就是调用的Runnable接口所以你可以继承java.lang.Thread 类或者直接调用Runnable接口来重写run()方法实现线程。

4，Java 关键字volatile 与 synchronized 作用与区别？

1，volatile

它所修饰的变量不保留拷贝，直接访问主内存中的。

在Java内存模型中，有main memory，每个线程也有自己的memory (例如寄存器)。为了性能，一个线程会在自己的memory中保持要访问的变量的副本。这样就会出现同一个变量在某个瞬间，在一个线程的memory中的值可能与另外一个线程memory中的值，或者main memory中的值不一致的情况。一个变量声明为volatile，就意味着这个变量是随时会被其他线程修改的，因此不能将它cache在线程memory中。

2，synchronized

当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

四、当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

五、以上规则对其它对象锁同样适用。

5，有哪些不同的线程生命周期？

当我们在Java程序中新建一个线程时，它的状态是New。当我们调用线程的start()方法时，状态被改变为Runnable。线程调度器会为Runnable线程池中的线程分配CPU时间并且讲它们的状态改变为Running。其他的线程状态还有Waiting，Blocked 和Dead。

6，你对线程优先级的理解是什么？

每一个线程都是有优先级的，一般来说，高优先级的线程在运行时会具有优先权，但这依赖于线程调度的实现，这个实现是和操作系统相关的(OS dependent)。我们可以定义线程的优先级，但是这并不能保证高优先级的线程会在低优先级的线程前执行。线程优先级是一个int变量(从1-10)，1代表最低优先级，10代表最高优先级。

7，什么是死锁(Deadlock)？如何分析和避免死锁？

死锁是指两个以上的线程永远阻塞的情况，这种情况产生至少需要两个以上的线程和两个以上的资源。

【励志】写给立志做码农的大学生

Tue, 12 Sep 2017 19:30:31 +0800

确定方向

选择比努力更重要。

关于方向的选择其实越早确定越好，生活中我们要面临无数个选择，前几天看的一个黑客相关的美剧中有句台词说的不错：

life is binary.

生活就是二进制，一个个0101组成的。每一次抉择，选了就是1，不选就是0。另外也有一句话说：“人一生要面临很多选择，但是真正能决定你命运的只有几个”。没错其实就是这样。

如果你是计算机专业的学生，那么到底是考研还是就业就是首先要面临的问题。本文是面向确定了毕业要工作的大学生的，所以关于这个抉择，不再赘述。

就业的话，本文标题是码农，实际是指所有计算机相关的技术工种。包括开发、测试、运维等。

很多选择本身并没有对错或优劣，只有适合不适合。

不要滥用勤能补拙，这个词语一度被很多人奉为圭臬，但同时成了枷锁。我相信这个词，但是要考虑现状，要考虑投资回报率。你在自己并不擅长或不感兴趣的领域深耕了四年，最后不一定能获得多少成绩。当然如果你能在毕业后继续深耕几年或许是可以的，但是我希望每一位大学生在毕业的时候都能有一份好的工作，并且如果你并不喜欢某一领域的话，那么我相信你一定不会坚持下去。所以我们一定要找到适合自己的方向！

那么如何发现自己对什么感兴趣呢？我也不知道很好的办法，我只知道一个朴素的方法——尝试。趁着年轻，就要多尝试。千万不要大三了都还不知道自己兴趣在哪，想做什么，适合什么。所以大一大二努力去碰钉子吧。

算法还是开发？

数据结构和算法很重要，无论是面试还是工作，无论你从事哪方面的技术。不过算法虽然重要，但并不适合每个人都花费大学全部的精力去钻研。

相信很多学校都有ACM竞赛相关的社团或组织。很不幸，我们学校没有，我大一的时候也花了很多精力刷题，但是硬件条件不太允许，氛围太缺乏。如果你觉得自己能够在ACM比赛中游刃有余，那么恭喜你，你可以一心一意搞算法。如果你觉得自己在这个过程中十分吃力，挫败感频生，那么也不要气馁，或许有另一条路是属于你的。选择开发，有算法功底深厚是很棒的事，但是仅仅只有算法同样是不够的，计算机海洋还有很多未知等着你探索。

算法岗包括数据挖掘、机器学习之类的（怎么样，高大上吧，反正我不懂）。要说明的是想做算法的同学最好选择读研继续深造，因为大企业在算法岗的招聘上对本科生是很不友好的。还是要申明一句，你做开发也不能忽视算法和数据结构，起码面试还是经常考的！记住一句：

算法功底好的人，运气都不会差。

对于本科生而言做开发还是相对容易的一条道路，不过开发的技术路线也是不胜枚举：前端、后台（PHP后台、Java后台等等）、移动端（安卓和iOS）、游戏开发、数据库（比如做DBA）……。这里我肯定不会去推荐你去学哪一种，我没有能力也不适合。只有你自己才能发现自己的兴趣以及好奇心之所在。

我能做的只是在浩如烟海的技术观点中，帮一个个本科生排疑解惑。

认识技术

关于技术，很多本科生都存在诸多误区。初学者总喜欢追随牛逼的技术，实在过于盲目，找准自己的定位最重要。

误区1：图形化的东西比非图形化东西更牛逼

多见于初学者，尤其是计算机专业新生（我大一的时候就是）。当时学校教了点C语言，一直都是控制台程序，面对黑窗口，我就各种百度看看怎么弄出图形化的东西，那时候才知道GUI这个缩写是啥意思（当初知道这个缩写的全称还小激动了一下下，果然我还是太年轻了），然后知道了WIN32、MFC这些名词。确实只能说是知道名词。当时对着视频教程做了计算器，就是用VC++拖拖控件，视频里的人敲一句代码，我就敲一句。后面虽然弄出来了，但是感觉自己什么都不懂，只是依样画葫芦。这时我才意识到，还有很多基础没有打牢。

八卦一下，现在桌面客户端的开发工作并不多，所以大家谨慎选择这一技术方向。桌面端GUI技术一度火爆（MFC、Qt、WinForm、WPF、Swing……），但如今早已是互联网及移动互联网时代，所以大家真的要慎重选择。不过还是可以学习一下的，至少能加深你对编程语言以及设计模式的理解。

java程序员如何规划自己的职业生涯

Mon, 11 Sep 2017 19:30:20 +0800

IT行业越来越繁荣、成熟，随着移动互联网、java编程语言的普及，愈发有很多java程序员进入这个行业，java程序员面临自身能力提升时更多关注的是自身的硬实力，即技术功底、专业知识; java程序员如何规划自己的职业生涯，软技能的提升与硬实力同等重要，有时可能更为重要。

1. 专注力

在日常工作和生活中，我们可能时常被打断，特别是当我们进行编码工作时被打断后，往往需要半个小时或更长时间来找回当时的工作状态。挑选时间片段专注于单一任务的方法，可以帮助程序员从这种状态中脱离出来。当然自己也要学会建立防火墙，专注时间内的其它可能打扰自己的因素需要及时避免，如即时通信软件、微信等。专注于完成单一任务，不要期望并行任务完成得很好，经常性的被打断会造成专注力的缺失，对于程序员来说缺乏专注力是致命的。

2. 时间管理

总是感觉一天什么都还没有做，时间就溜走了。分享一个我对于时间利用方式的理解，即碎片事情用碎片时间，完整事情用成块时间。怎么理解呢?我们日常有很多的碎片事情，如查邮件、刷微博、看微信等，这样的事情就可以利用碎片时间来做，例如上厕所、等公交、坐地铁等;例如完成产品某一功能便是完整事情，需要利用成块的非打扰时间来完成，这样才会将时间利用好。

3. 对自己负责

不论是提升工作效率，还是学习新的技能，都是在给自己积累经验和知识，在进行工作输出时，需要对自己所完成的内容进行负责，使其达到最好的状态和输出标准，这一切的努力都是在对自己负责。

4. 有效努力工作

加班是程序员跑不掉的话题，需要思考的是，在自己的工作内容里面，完成时到底用了多少有效时间，千万不要只是看上去很努力，做了很多无用功或是浪费了时间。当然，如果你公司文化是由加班多少来决定晋升和绩效的，要么玩这个游戏，要么离开这样的公司。

Java面试经验，兼谈互联网公司后端面试经验

Sun, 10 Sep 2017 19:47:01 +0800

应聘相关

声明：

程序员相关的哈

万事无定论，比如说，就算你小学毕业，但是java基础却扎实到变态，我相信open的公司还是会给你机会的。

心态很重要，虽然日常的心态不容易控制，面试那俩小时的心态，只要你想，就能控制。

1、先来一份前辈的劝戒

坚持三年，不管在哪干，有一个好的平台，坚持三年以上才能出效果。

如果跳的话，新公司需要稳定，最少过了B轮融资，，五万比一是创业型公司的失败率

不要着急，不要比较为了5000块的工资差价跳，不值得跳，从一万到三万，并且有一个好的平台的话，才值得跳。

长期的看普华挺好的，从平台上讲，除了BAT华为，基本没有更好的

每天要多投些简历，每天投个几十份，别着急，多面面。

2、再来一份傲骄的互联网公司的不收标准

符合以下条件的不要

二本以下，特别是学校名XXX学院

应届或者未毕业

在职并且不打算换工作

目标非北京

纯 windows / asp / c# / c sharp / .net / dot net

纯嵌入式

纯移动端 android / iOS

特别底层，比如操作系统内核裁剪

非计算机专业，计算机工作经验在一年以下

最近的项目，空白超过半年，比如现在8月份，项目经历只写到2月

87 年以前，除非背景特别牛

Java集合类

Fri, 08 Sep 2017 21:07:49 +0800

看了一些所谓大公司的JAVA面试问题，发现对于JAVA集合类的使用都比较看重似的，而自己在这方面还真的是所真甚少，抽空也学习学习吧。

java.util包中包含了一系列重要的集合类，而对于集合类，主要需要掌握的就是它的内部结构，以及遍历集合的迭代模式。

接口：Collection

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。

所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。

主要的一个接口方法：boolean add(Ojbect c)

虽然返回的是boolean，但不是表示添加成功与否，这个返回值表示的意义是add()执行后，集合的内容是否改变了（就是元素的数量、位置等有无变化）。类似的addAll，remove，removeAll，remainAll也是一样的。

用Iterator模式实现遍历集合

Collection有一个重要的方法：iterator()，返回一个Iterator（迭代器），用于遍历集合的所有元素。Iterator模式可以把访问逻辑从不同的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。典型的用法如下：

Iterator it = collection.iterator(); // 获得一个迭代器
while(it.hasNext()) {
Object obj = it.next(); // 得到下一个元素
}

不需要维护遍历集合的“指针”，所有的内部状态都由Iterator来维护，而这个Iterator由集合类通过工厂方法生成。

每一种集合类返回的Iterator具体类型可能不同，但它们都实现了Iterator接口，因此，我们不需要关心到底是哪种Iterator，它只需要获得这个Iterator接口即可，这就是接口的好处，面向对象的威力。

要确保遍历过程顺利完成，必须保证遍历过程中不更改集合的内容（Iterator的remove()方法除外），所以，确保遍历可靠的原则是：只在一个线程中使用这个集合，或者在多线程中对遍历代码进行同步。

由Collection接口派生的两个接口是List和Set。　

List接口

List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。和下面要提到的Set不同，List允许有相同的元素。

除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。

实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

LinkedList类

LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。

注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：List list = Collections.synchronizedList(new LinkedList(...));

ArrayList类

ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。

size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。

每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。

和LinkedList一样，ArrayList也是非同步的（unsynchronized）。

如何掌握所有的程序语言

Thu, 31 Aug 2017 19:57:47 +0800

对的，我这里要讲的不是如何掌握一种程序语言，而是所有的……

很多编程初学者至今还在给我写信请教，问我该学习什么程序语言，怎么学习。由于我知道如何掌握“所有”的程序语言，总是感觉这种该学“一种”什么语言的问题比较低级，所以一直没来得及回复他们 :P 可是逐渐的，我发现原来不只是小白们有这个问题，就连美国大公司的很多资深工程师，其实也没搞明白。

今天我有动力了，想来统一回答一下这个搁置已久的“初级问题”。类似的话题貌似曾经写过，然而现在我想把它重新写一遍。因为在跟很多人交流之后，我对自己头脑中的（未转化为语言的）想法，有了更精准的表达。

如果你存在以下的种种困惑，那么这篇文章也许会对你有所帮助：

你是编程初学者，不知道该选择什么程序语言来入门。

你是资深的程序员或者团队领导，对新出现的种种语言感到困惑，不知道该“投资”哪种语言。

你的团队为使用哪种程序语言争论不休，发生各种宗教斗争。

你追逐潮流采用了某种时髦的语言，结果两个月之后发现深陷泥潭，痛苦不堪……

虽然我已经不再过问这些世事，然而无可置疑的现实是，程序语言仍然是很重要的话题，这个情况短时间内不会改变。程序员的岗位往往会要求熟悉某些语言，甚至某些奇葩的公司要求你“深入理解 OOP 或者 FP 设计模式”。对于在职的程序员，程序语言至今仍然是可以争得面红耳赤的宗教话题。它的宗教性之强，以至于我在批评和调侃某些语言（比如 Go 语言）的时候，有些人会本能地以为我是另外一种语言（比如 Java）的粉丝。

显然我不可能是任何一种语言的粉丝，我甚至不是 Yin 语言的粉丝 ;) 对于任何从没见过的语言，我都是直接拿起来就用，而不需要经过学习的过程。看了这篇文章，也许你会明白我为什么可以达到这个效果。理解了这里面的东西，每个程序员都应该可以做到这一点。嗯，但愿吧。

重视语言特性，而不是语言

很多人在乎自己或者别人是否“会”某种语言，对“发明”了某种语言的人倍加崇拜，为各种语言的孰优孰劣争得面红耳赤。这些问题对于我来说都是不存在的。虽然我写文章批评过不少语言的缺陷，在实际工作中我却很少跟人争论这些。如果有其它人在我身边争论，我甚至会戴上耳机，都懒得听他们说什么 ;) 为什么呢？我发现归根结底的原因，是因为我重视的是“语言特性”，而不是整个的“语言”。我能用任何语言写出不错的代码，就算再糟糕的语言也差不了多少。

任何一种“语言”，都是各种“语言特性”的组合。打个比方吧，一个程序语言就像一台电脑。它的牌子可能叫“联想”，或者“IBM”，或者“Dell”，或者“苹果”。那么，你可以说苹果一定比 IBM 好吗？你不能。你得看看它里面装的是什么型号的处理器，有多少个核，主频多少，有多少 L1 cache，L2 cache……，有多少内存和硬盘，显示器分辨率有多大，显卡是什么 GPU，网卡速度，等等各种“配置”。有时候你还得看各个组件之间的兼容性。

这些配置对应到程序语言里面，就是所谓“语言特性”。举一些语言特性的例子：

变量定义

算术运算

for 循环语句，while 循环语句

函数定义，函数调用

递归

静态类型系统

类型推导

lambda 函数

面向对象

垃圾回收

指针算术

goto 语句

这些语言特性，就像你在选择一台电脑的时候，看它里面是什么配置。选电脑的时候，没有人会说 Dell 一定是最好的，他们只会说这个型号里面装的是 Intel 的 i7 处理器，这个比 i5 的好，DDR3 的内存比 DDR2 的快这么多，SSD 比磁盘快很多，ATI 的显卡是垃圾…… 如此等等。

怎么开始使用Java机器学习？

Wed, 30 Aug 2017 20:36:01 +0800

本文咱们会做一个java的机械进修的重要框架的疾速概述，并证实Java机械进修是何等轻易上手，不必要你重新努力别辟门户或许从头开端创立算法。

开端Java机械进修的最佳工具是甚么?

这个成绩曾经有一段时间了，但近来这些日子险些每个人都在评论辩论人工智能和机械进修。这曾经再也不是一个保留给科学家和研究者的机密，而是险些完成于每一项新兴技巧中。

鄙人面的章节中，咱们会做一个java的机械进修的重要框架的疾速概述，并证实Java机械进修是何等轻易上手，不必要你重新努力别辟门户或许从头开端创立算法。

人类的人工智能

人工智能在一段时间以来是一个普遍而且炫酷的范畴，但老是感到有点难以涉及，是特别为科学家所做。假如你想发明一个人工智能体系，你必需完成你自己的焦点算法，而且练习它们能辨认形式，懂得图象而且处置自然说话。

近来对付这范畴的蜕变使得其对付非研究者能更轻易涉及。你如今能轻易涉及到相干算法和工具。你不必要晓得你正在做甚么，然则能很轻松的晋升你应用的机械进修才能。

让机械运行

为了更简单的论述，咱们决议选出3个名目赞助你开端：

1.Deeplearning4J (DL4J) –开源，分布式，JVM的贸易深度进修lib库

2. BID Data Project –可以或许运行疾速、大规模的机械进修和数据挖掘的形式聚集

3. Neuroph –面向工具的神经收集

趁便说一下, 咱们近来宣布了别的一些吸引咱们留意的风趣的开源GitHub库. 下载.

DL4J – 深度进修

DL4J是一个能赞助你设置装备摆设多层神经收集的工具。它为JVM供给了深度进修且随同疾速原型计划和大规模定制，同时重视比设置装备摆设更多的商定。

这个工具是为了赞助曾经领有创立和应用神经收集的实践，但不想亲身完成算法的那些人。你可以或许在海量数据上办理特定成绩和自定义神经收集属性。

DL4J 是由Java说话编写的，可以或许兼容任何JVM说话好比 Clojure, Scala, ,Kotlin，而且可以或许与Hadoop和Spark集成。

能够的应用案例包括评估或保举体系如(CRM，adtech， churn prevention)，猜测阐发乃至讹诈检测。假如你要探求实在的案例，你可以或许下载 Rapidminer. 这是应用DL4J的开源平台，用来为用户简化猜测阐发进程。

创立一个新的神经收集犹如创立一个新名目同样轻易。

BID Data Project (大数据名目)

大数据名目是由那些必要处置大批数据而且对机能敏感的人创立的。 UC Berkeley名目是由很多硬件、软件和计划形式聚集而成，能在上应用疾速、大规模的数据挖掘。

第一个库是 BIDMach，在单节点或集群上的惯例机械进修成绩都有记载。你可以或许应用这个库治理数据源，在CPU或许GPU上优化、分派数据。

BidMach 外面包括很多流行的机械进修算法，他们团队正致力于开辟分布式神经收集、图形算法和其余模子

其余两个库分别是BIDMat和 BIDParse。BIDMat是存眷与数据挖掘的疾速数学矩阵库，BIDParse是GPU加快的自然说话剖析。大数据名目标其余类库还包括可视化工具，可以或许支撑在Spark乃至在安卓运行的类库。

BIDMach基准比其余办理计划持续表现出更好的成果。乃至将其在繁多机械上的运行与其余计划在大集群上的运行比拟也是如斯。在这里可以或许找到一个完备的基准列表。

Neuroph

neuroph是用来开辟常用的神经收集构架的轻量级java框架。该框架供给了一个java库和一个GUI工具(称为easyNeurons)，你可以或许用它来在java名目中创立和练习自己的神经收集。

Neuroph包括一个开源的java类库和大批对应根本神经收集观点的基类。对付刚开端应用神经收集，或许想晓得它们若何事情的人来讲，Neuroph是个异常好的垫脚石。

你可以或许测验考试Neuroph的在线演示，看看它是怎样运行的。提醒：界面看起来很旧且过期，但你可以或许用它来创立美好的器械。它还得过2013的 Duke’s Choice的奖项。

收集视图

其余名目若何呢?

万一以上三个名目不是你所必要的，你想为你的名目探求一些分歧的，也不要紧。假如你在GitHub上搜刮“机械进修”，将有1506个Java资本让你找到适合的工具。

举个例子， Airbnb中有个风趣的名目是aerosolve,一个计划成具备人类友爱性的机械进修库。

开端进修一项新的技巧很费事，假如您希冀获得一些赞助，确保你曾经下载了Takipi的差错阐发工具。

最后的思虑

每隔几年就会有些对付人工智能的新声响。这一次，它伴跟着机械进修，数据挖掘，神经收集等等的强化来了，咱们都很支撑。这些类库开源的现实意味着这些信息和才能正奇货可居，而你一切所做的是思虑领有这个才能可以或许做成甚么。

假如你晓得其余风趣的名目或许你觉得咱们遗漏点甚么，咱们等待鄙人面的批评里见到它们。

Java中堆内存和栈内存详解

Sun, 27 Aug 2017 19:13:26 +0800

Java把内存分成两种，一种叫做栈内存，一种叫做堆内存.

在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量分配的内存空间，该内存空间可以立刻被另作他用。

堆内存用于存放由new创建的对象和数组。在堆中分配的内存，由java虚拟机自动垃圾回收器来管理。在堆中产生了一个数组或者对象后，还可以在栈中定义一个特殊的变量，这个变量的取值等于数组或者对象在堆内存中的首地址，在栈中的这个特殊的变量就变成了数组或者对象的引用变量，以后就可以在程序中使用栈内存中的引用变量来访问堆中的数组或者对象，引用变量相当于为数组或者对象起的一个别名，或者代号。

引用变量是普通变量，定义时在栈中分配内存，引用变量在程序运行到作用域外释放。而数组＆对象本身在堆中分配，即使程序运行到使用new产生数组和对象的语句所在地代码块之外，数组和对象本身占用的堆内存也不会被释放，数组和对象在没有引用变量指向它的时候，才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。这个也是java比较占内存的主要原因，实际上，栈中的变量指向堆内存中的变量，这就是 Java 中的指针!

java中内存分配策略及堆和栈的比较

1 内存分配策略

按照编译原理的观点,程序运行时的内存分配有三种策略,分别是静态的,栈式的,和堆式的.

静态存储分配是指在编译时就能确定每个数据目标在运行时刻的存储空间需求,因而在编译时就可以给他们分配固定的内存空间.这种分配策略要求程序代码中不允许有可变数据结构(比如可变数组)的存在,也不允许有嵌套或者递归的结构出现,因为它们都会导致编译程序无法计算准确的存储空间需求.

栈式存储分配也可称为动态存储分配,是由一个类似于堆栈的运行栈来实现的.和静态存储分配相反,在栈式存储方案中,程序对数据区的需求在编译时是完全未知的,只有到运行的时候才能够知道,但是规定在运行中进入一个程序模块时,必须知道该程序模块所需的数据区大小才能够为其分配内存.和我们在数据结构所熟知的栈一样,栈式存储分配按照先进后出的原则进行分配。

静态存储分配要求在编译时能知道所有变量的存储要求,栈式存储分配要求在过程的入口处必须知道所有的存储要求,而堆式存储分配则专门负责在编译时或运行时模块入口处都无法确定存储要求的数据结构的内存分配,比如可变长度串和对象实例.堆由大片的可利用块或空闲块组成,堆中的内存可以按照任意顺序分配和释放.

2 堆和栈的比较

上面的定义从编译原理的教材中总结而来,除静态存储分配之外,都显得很呆板和难以理解,下面撇开静态存储分配,集中比较堆和栈:

从堆和栈的功能和作用来通俗的比较,堆主要用来存放对象的，栈主要是用来执行程序的.而这种不同又主要是由于堆和栈的特点决定的:

在编程中，例如C/C++中，所有的方法调用都是通过栈来进行的,所有的局部变量,形式参数都是从栈中分配内存空间的。实际上也不是什么分配,只是从栈顶向上用就行,就好像工厂中的传送带(conveyor belt)一样,Stack Pointer会自动指引你到放东西的位置,你所要做的只是把东西放下来就行.退出函数的时候，修改栈指针就可以把栈中的内容销毁.这样的模式速度最快, 当然要用来运行程序了.需要注意的是,在分配的时候,比如为一个即将要调用的程序模块分配数据区时,应事先知道这个数据区的大小,也就说是虽然分配是在程序运行时进行的,但是分配的大小多少是确定的,不变的,而这个”大小多少”是在编译时确定的,不是在运行时.

堆是应用程序在运行的时候请求操作系统分配给自己内存，由于从操作系统管理的内存分配,所以在分配和销毁时都要占用时间，因此用堆的效率非常低.但是堆的优点在于,编译器不必知道要从堆里分配多少存储空间，也不必知道存储的数据要在堆里停留多长的时间,因此,用堆保存数据时会得到更大的灵活性。事实上,面向对象的多态性,堆内存分配是必不可少的,因为多态变量所需的存储空间只有在运行时创建了对象之后才能确定.在C++中，要求创建一个对象时，只需用 new命令编制相关的代码即可。执行这些代码时，会在堆里自动进行数据的保存.当然，为达到这种灵活性，必然会付出一定的代价:在堆里分配存储空间时会花掉更长的时间!这也正是导致我们刚才所说的效率低的原因,看来列宁同志说的好,人的优点往往也是人的缺点,人的缺点往往也是人的优点(晕~).

3 JVM中的堆和栈

JVM是基于堆栈的虚拟机.JVM为每个新创建的线程都分配一个堆栈.也就是说,对于一个Java程序来说，它的运行就是通过对堆栈的操作来完成的。堆栈以帧为单位保存线程的状态。JVM对堆栈只进行两种操作:以帧为单位的压栈和出栈操作。

我们知道,某个线程正在执行的方法称为此线程的当前方法.我们可能不知道,当前方法使用的帧称为当前帧。当线程激活一个Java方法,JVM就会在线程的 Java堆栈里新压入一个帧。这个帧自然成为了当前帧.在此方法执行期间,这个帧将用来保存参数,局部变量,中间计算过程和其他数据.这个帧在这里和编译原理中的活动纪录的概念是差不多的.

从Java的这种分配机制来看,堆栈又可以这样理解:堆栈(Stack)是操作系统在建立某个进程时或者线程(在支持多线程的操作系统中是线程)为这个线程建立的存储区域，该区域具有先进后出的特性。

每一个Java应用都唯一对应一个JVM实例，每一个实例唯一对应一个堆。应用程序在运行中所创建的所有类实例或数组都放在这个堆中,并由应用所有的线程共享.跟C/C++不同，Java中分配堆内存是自动初始化的。Java中所有对象的存储空间都是在堆中分配的，但是这个对象的引用却是在堆栈中分配,也就是说在建立一个对象时从两个地方都分配内存，在堆中分配的内存实际建立这个对象，而在堆栈中分配的内存只是一个指向这个堆对象的指针(引用)而已。

Java 中的堆和栈

Java把内存划分成两种：一种是栈内存，一种是堆内存。

在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。

当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。

堆内存用来存放由new创建的对象和数组。

在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。

在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。

引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。

具体的说：

栈与堆都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。

搞 Java 的程序员，年薪 40W 需要什么水平？

Wed, 23 Aug 2017 15:20:47 +0800

前几天在网上看到这么一个问题，搞Java的程序员年薪40w 是个什么水平？

一下勾起了我的兴趣，今天就来简单分析下，到底是什么水平。

那么我们先来搞清楚"JAVA"是谁家姑娘？

......

不不不，方向搞错了。。

那么我们先来搞清楚，年薪40W，这个是税前还是税后。
•阿里薪资结构：一般是12+1+3=16薪
•年底的奖金为0-6个月薪资，90%人可拿到3个月

JAVA修改、删除数据之后刷新JTable的方法

Sun, 20 Aug 2017 17:04:58 +0800

以下代码不完整，仅把关键的代码贴出来

String userTitle[] = {"ID","用户名","密码","邮箱","名字","等级"};

tab = new Object[userInfoNumber][6];

Iterator<User> iter = userList.iterator();

while(iter.hasNext()){

User user = iter.next();

tab[i][0] = user.getId();

tab[i][1] = user.getUserName();

tab[i][2] = user.getPwd();

tab[i][3] = user.getMail();

tab[i][4] = user.getName();

whatGrade = user.getGrade() == 1 ? "管理员" : "普通会员";

tab[i][5] = whatGrade;

i ++;

}

DefaultTableModel tableModel = new DefaultTableModel(tab,userTitle);

JTable table = new JTable(tableModel);

for(int j = 0;j < table.getRowCount();j ++){

导出含有图片的Java项目，图片不显示

Sun, 20 Aug 2017 16:55:36 +0800

项目的一些图片资源文件在导出成JAR包后，无法正确读取虽然Java项目还是可以运行，但原来的图片资源全不见了，于是你可以打开JAR包看看里面的东西，确实是有图片在里面，就是无法读取。

其实是因为我们在导出成JAR包后，图片资源的路径已经发生了变化，造成无法读取的问题

首先在项目的SRC目录下建立一个包，然后再把图片等资源放进包中，然后再通过下面的方法进行读取：

ImageIcon img = new ImageIcon(【你的主类名称】.class.getgetResource("/pic/index.png"));

比如我在SRC目录下建立了一个pic包，包下面放了一张图片index.png，我的读取图片主类是MySample，那么我需要读取index.png这张图片时就要这样做：

ImageIcon indexImage = new ImageIcon(MySample.class.getgetResource("/pic/index.png"));

要注意的是路径中pic前面的斜杠不可少，否则会报错读取不到资源造成空指针，其他如音频资源也是类似做法。

转载自【Java编程精选】关于 Java 你不知道的十件事

Sat, 19 Aug 2017 20:49:33 +0800

作为Java 控，我们总是对不太可能直接使用，但能使我们更了解 Java 和 Java 虚拟机（Java Virtual Machine，JVM）的晦涩细节感兴趣。这也是我将 Lukas Eder 在 jooq.org 上写的这篇文章发布出来的原因。

你在Java发布的时候就开始使用了吗？还记得那时它叫“Oak”，面向对象也（Object Oriented， OO ）还是个热门话题，C++ 程序员们觉得 Java 完全没机会成功，Applet的出现也是一件新鲜大事？

我打赌下文中至少一半的内容你都不知道。让我们来看看这些令人惊喜的 Java 细节吧。

1. 受检异常（checked exception）这件事是不存在的

是这样的，JVM 完全不知道这件事，都是Java语言做的[只有Java语言这么干]。

现在，异常检查被公认为是个错误，正如 Brue Eckel 在布拉格的 GeeCON 大会上的闭幕词中所说， Java 后的其他语言都不再使用异常检查了，就连 Java 8 都不愿在新的 Stream API 中使用它了（当你在 lambda 表达式中使用 IO 或者 JDBC 时，是很痛苦的）。

你想要证明 JVM 不知道异常检查这件事吗？尝试以下代码：

这个不仅会编译，还会抛出 SQLException ，你甚至不需要 Lombok 的 @SneakyThrows 标签。

更多详情请参考这篇文章，或者 Stack Overflow 上的这篇文章。

2. 可以使用不同的返回值类型来重载方法

以下代码是编译不过的，对吧？

java.lang.StackOverflowError 异常解决办法

Sat, 19 Aug 2017 19:43:46 +0800

这个错误是相互引用,导致连锁栈溢出,不知道那块循环没有停下来所以进程就一直在跑

我一直在找到底哪的循环没停下来然后还是没找到。直接调用没错误就是加表格上就出错别的窗口都没错误就是这个论文查询有错误

到最后发现就是接口调用的时候写错单词了心里十万个草泥马奔腾而过

这个错误的官方解释是：

递归调用没有明确的结束

仔细查看自己的递归调用程序

举例：递归没有边界条件或者递归的边界条件永远不能达到

所以你就找找你哪里少写了几句实在不行就重写

结论：没有找不到的Bug 只有不努力没有耐心的人

科研管理系统--ResAbout 关于界面代码设计

Fri, 18 Aug 2017 20:11:06 +0800

package view;

import java.awt.AWTEvent;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Image;
import java.awt.Insets;
import java.awt.MediaTracker;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;
import java.net.URLClassLoader;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

import com.jnzj.common.Commom;

public class ResAbout extends JFrame implements ActionListener{
	Image icon;
	ImageIcon banner;
	JLabel jLabel;
	JLabel jLabel2;
	JLabel jLabel3;
	JLabel jLabel4;
	JLabel jLabel5;
	JPanel jPanel;
	JPanel jPanel2;
	JPanel jPanel3;
	JButton jButton;
	private GridBagConstraints girdBagCon;
	private GridBagLayout girdBag=new GridBagLayout();
	public ResAbout() {
		// TODO Auto-generated constructor stub
		this.setLayout(new BorderLayout());//边框布局
		//enableEvents(AWTEvent.WINDOW_EVENT_MASK);
		//添加框架的关闭时间处理2
		//this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		//窗口自适应大小 使窗体能正好显示里面的所有控件
		this.pack();
		//设置框架的大小
		this.setSize(500,400);
		//设置窗体的标题
		this.setTitle("关于");
		//调用自定义的方法GetImage（） ，获取图标文件
		icon=getImage("icon.png");
		//设置窗体图标
		this.setIconImage(icon);
		//设置不能调整窗体的大小
		this.setResizable(false);
		//获取屏幕大小
		Dimension screenSize=Toolkit.getDefaultToolkit().getScreenSize();
		//获取当前项目的窗体大小
		Dimension frameSize=this.getSize();
		//如果项目窗体高>屏幕高，用屏幕高设置项目窗体高
		if (frameSize.height>screenSize.height) {
			frameSize.height=screenSize.height;
		}
		if (frameSize.width>screenSize.width) {
			frameSize.width=screenSize.width;
		}
		//设置窗体起始显示位置 居中显示
		this.setLocation((screenSize.width-frameSize.width)/2,
		(screenSize.height-frameSize.height)/2);
		try {
			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
		} catch (ClassNotFoundException | InstantiationException | IllegalAccessException
				| UnsupportedLookAndFeelException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		try {
			top();
			central();
			down();
			addListener();//监听
			this.setVisible(true);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		
		
	}
	private void addListener() {
		// TODO Auto-generated method stub
		jButton.addActionListener(this);
		
	}
	public void top() {
		jPanel=new JPanel();
		jPanel.setLayout(girdBag);
		jLabel=new JLabel("1.科研管理系统V1.0\t");
		jLabel.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=1;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		//girdBagCon.insets=new Insets(0, 10, 10, 1);
		girdBag.setConstraints(jLabel, girdBagCon);

		jLabel2=new JLabel("2.版权归2017doft公司所有 翻录必究");
		jLabel2.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=2;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		//girdBagCon.insets=new Insets(0, 10, 10, 1);
		girdBag.setConstraints(jLabel2, girdBagCon);
		
		jLabel3=new JLabel("3.联系方式：");
		jLabel3.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=3;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		//girdBagCon.insets=new Insets(0, 10, 10, 1);
		girdBag.setConstraints(jLabel3, girdBagCon);
		
		jLabel4=new JLabel("4.我们的口号是：代码演绎人生 算法助推梦想");
		jLabel4.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=4;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		//girdBagCon.insets=new Insets(0, 10, 10, 1);
		girdBag.setConstraints(jLabel4, girdBagCon);
		jPanel.add(jLabel);
		jPanel.add(jLabel);
		jPanel.add(jLabel2);
		jPanel.add(jLabel3);
		jPanel.add(jLabel4);	
		this.add(jPanel,BorderLayout.NORTH);
		
	}
	public void central() {
		jPanel2=new JPanel();

		banner=new ImageIcon("res/image.png");
		jLabel5=new JLabel(banner);
		jPanel2.add(jLabel5);
		this.add(jPanel2,BorderLayout.CENTER);
	}
	public void down() {
		jPanel3=new JPanel();
		this.add(jPanel3,BorderLayout.SOUTH);
		jButton=new JButton("关闭");
		jPanel3.add(jButton);
	}
	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		Object object=e.getSource();
		if (object==jButton) {
			this.setVisible(false);
		}
		
	}

	/** * 通过给定的文件名获得图像 */
	
	Image getImage(String filename){ 
		//URLClassLoader--用于从指向 jar文件和目录的 URL 的搜索路径加载类和资源。
		URLClassLoader urlLoader=(URLClassLoader) this.getClass().getClassLoader(); 
		
		URL url=null; 
		Image image=null;
		url=urlLoader.findResource(filename); 
		image=Toolkit.getDefaultToolkit().getImage(url); 
		MediaTracker mediaTracker=new MediaTracker(this); 
		 try { 
			 mediaTracker.addImage(image, 0); 
			 mediaTracker.waitForID(0); 
		 }catch (InterruptedException _ex){
			 image=null;
		 }
		 if (mediaTracker.isErrorID(0)) {
			 image=null;
		 }
		 return image;
	}
}

科研管理系统--ResHelp 帮助界面代码设计

Fri, 18 Aug 2017 20:08:24 +0800

package view;

import java.awt.AWTEvent;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Image;
import java.awt.Insets;
import java.awt.MediaTracker;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;
import java.net.URLClassLoader;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

import com.jnzj.common.Commom;

public class ResHelp extends JFrame implements ActionListener{
	Image icon;
	ImageIcon banner;
	JLabel jLabel6;
	JLabel jLabel;
	JLabel jLabel2;
	JLabel jLabel3;
	JLabel jLabel4;
	JLabel jLabel5;
	JPanel jPanel;
	JPanel jPanel2;
	JPanel jPanel3;
	JButton jButton;
	private GridBagConstraints girdBagCon;
	private GridBagLayout girdBag=new GridBagLayout();
	public ResHelp() {
		// TODO Auto-generated constructor stub
		this.setLayout(new BorderLayout());//边框布局
		//enableEvents(AWTEvent.WINDOW_EVENT_MASK);
		//添加框架的关闭时间处理2
		//this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		//窗口自适应大小 使窗体能正好显示里面的所有控件
		this.pack();
		//设置框架的大小
		this.setSize(700,200);
		//设置窗体的标题
		this.setTitle("帮助");
		//调用自定义的方法GetImage（） ，获取图标文件
		icon=getImage("icon.png");
		//设置窗体图标
		this.setIconImage(icon);
		//设置不能调整窗体的大小
		this.setResizable(false);
		//获取屏幕大小
		Dimension screenSize=Toolkit.getDefaultToolkit().getScreenSize();
		//获取当前项目的窗体大小
		Dimension frameSize=this.getSize();
		//如果项目窗体高>屏幕高，用屏幕高设置项目窗体高
		if (frameSize.height>screenSize.height) {
			frameSize.height=screenSize.height;
		}
		if (frameSize.width>screenSize.width) {
			frameSize.width=screenSize.width;
		}
		//设置窗体起始显示位置 居中显示
		this.setLocation((screenSize.width-frameSize.width)/2,
		(screenSize.height-frameSize.height)/2);
		try {
			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
		} catch (ClassNotFoundException | InstantiationException | IllegalAccessException
				| UnsupportedLookAndFeelException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		try {
			top();
			central();
			down();
			addListener();//监听
			this.setVisible(true);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		
		
	}
	private void addListener() {
		// TODO Auto-generated method stub
		jButton.addActionListener(this);
		
	}
	public void top() {
		
		jPanel2=new JPanel();
		jPanel2.setLayout(girdBag);
		jLabel6=new JLabel("科研管理系统帮助");
		jLabel6.setFont(new Font("Dialog", 0, 16));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=0;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(0, 10, 0, 10);
		girdBag.setConstraints(jLabel6, girdBagCon);
		jPanel2.add(jLabel6);
		this.add(jPanel2,BorderLayout.NORTH);
	}
	public void central() {
		jPanel=new JPanel();
		jPanel.setLayout(girdBag);
		jLabel=new JLabel("1.科研管理系统是为了统计高校教师的科研成果");
		jLabel.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=1;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		//girdBagCon.insets=new Insets(0, 10, 10, 1);
		girdBag.setConstraints(jLabel, girdBagCon);

		jLabel2=new JLabel("2.以论文信息的统计为例子");
		jLabel2.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=2;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		//girdBagCon.insets=new Insets(0, 10, 10, 1);
		girdBag.setConstraints(jLabel2, girdBagCon);
		
		jLabel3=new JLabel("3.该论文系统实现了论文信息，作者信息，作者所在部门信息的管理，包括：添加，删除和修改");
		jLabel3.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=3;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		//girdBagCon.insets=new Insets(0, 10, 10, 1);
		girdBag.setConstraints(jLabel3, girdBagCon);
		
		jLabel4=new JLabel("4.该系统实现了论文信息，作者信息，作者和所在部门的不同条件查询");
		jLabel4.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=4;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		//girdBagCon.insets=new Insets(0, 10, 10, 1);
		girdBag.setConstraints(jLabel4, girdBagCon);
		jPanel.add(jLabel);
		jPanel.add(jLabel2);
		jPanel.add(jLabel3);
		jPanel.add(jLabel4);	
		this.add(jPanel,BorderLayout.CENTER);
		
	}
	public void down() {
		jPanel3=new JPanel();
		this.add(jPanel3,BorderLayout.SOUTH);
		jButton=new JButton("关闭");
		jPanel3.add(jButton);
	}
	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		Object object=e.getSource();
		if (object==jButton) {
			this.setVisible(false);
		}
		
	}

	/** * 通过给定的文件名获得图像 */
	
	Image getImage(String filename){ 
		//URLClassLoader--用于从指向 jar文件和目录的 URL 的搜索路径加载类和资源。
		URLClassLoader urlLoader=(URLClassLoader) this.getClass().getClassLoader(); 
		
		URL url=null; 
		Image image=null;
		url=urlLoader.findResource(filename); 
		image=Toolkit.getDefaultToolkit().getImage(url); 
		MediaTracker mediaTracker=new MediaTracker(this); 
		 try { 
			 mediaTracker.addImage(image, 0); 
			 mediaTracker.waitForID(0); 
		 }catch (InterruptedException _ex){
			 image=null;
		 }
		 if (mediaTracker.isErrorID(0)) {
			 image=null;
		 }
		 return image;
	}
}

科研信息管理系统-论文管理之菜单导航版

Thu, 17 Aug 2017 17:21:03 +0800

package view;

import java.awt.AWTEvent;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Image;
import java.awt.MediaTracker;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;
import java.net.URLClassLoader;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JToolBar;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.plaf.basic.BasicBorders;

public class ResearchMain extends JFrame implements ActionListener{
	//框架大小
	Dimension faceSize=new Dimension(950, 650);
	Image icon;
	ImageIcon banner;
	//程序图标
	JPanel panel1;
	JLabel jLabel;

	JMenuBar menuBar;
	
	JMenu menu1;
	JMenu menu2;
	JMenu menu3;
	JMenu menu4;
	JMenu menu5;
	
	JMenuItem item1;
	JMenuItem item2;
	JMenuItem item3;
	JMenuItem item4;
	JMenuItem item5;
	JMenuItem item6;
	JMenuItem item7;
	JMenuItem item8;
	JMenuItem item9;
	JMenuItem item10;
	
	//boolean packFame=false;
	public ResearchMain() {
		this.setLayout(new BorderLayout());//边框布局
		enableEvents(AWTEvent.WINDOW_EVENT_MASK);
		//添加框架的关闭时间处理2
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		//窗口自适应大小 使窗体能正好显示里面的所有控件
		this.pack();
		//设置框架的大小
		this.setSize(faceSize);
		//设置窗体的标题
		this.setTitle("科研信息管理系统");
		//调用自定义的方法GetImage（） ，获取图标文件
		icon=getImage("icon.png");
		//设置窗体图标
		this.setIconImage(icon);
		//设置不能调整窗体的大小
		this.setResizable(false);
		//获取屏幕大小
		Dimension screenSize=Toolkit.getDefaultToolkit().getScreenSize();
		//获取当前项目的窗体大小
		Dimension frameSize=this.getSize();
		//如果项目窗体高>屏幕高，用屏幕高设置项目窗体高
		if (frameSize.height>screenSize.height) {
			frameSize.height=screenSize.height;
		}
		if (frameSize.width>screenSize.width) {
			frameSize.width=screenSize.width;
		}
		//设置窗体起始显示位置 居中显示
		this.setLocation((screenSize.width-frameSize.width)/2,
		(screenSize.height-frameSize.height)/2);
		try {
			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
		} catch (ClassNotFoundException | InstantiationException | IllegalAccessException
				| UnsupportedLookAndFeelException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		try {
			bt();//初始化标题栏
			gj();//工具栏
			tp();//图片
			addListener();//监听
			this.setVisible(true);
	
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}		
		
	}
	public void bt() {
		menuBar=new JMenuBar();
		this.setJMenuBar(menuBar);
		menu1=new JMenu("系统设置");
		menuBar.add(menu1);
		menu2=new JMenu("论文信息管理");
		menuBar.add(menu2);
		menu3=new JMenu("教师信息管理");
		menuBar.add(menu3);
		menu4=new JMenu("部门信息管理");
		menuBar.add(menu4);
		menu5=new JMenu("帮助");
		menuBar.add(menu5);
		item1=new JMenuItem("用户管理");
		item2=new JMenuItem("退出系统");
		menu1.add(item1);
		menu1.add(item2);
		item3=new JMenuItem("论文信息管理");
		item4=new JMenuItem("论文信息查询");
		menu2.add(item3);
		menu2.add(item4);
		item5=new JMenuItem("教师基本信息管理");
		item6=new JMenuItem("教师基本信息查询");
		menu3.add(item5);
		menu3.add(item6);
		item7=new JMenuItem("部门基本信息管理");
		item8=new JMenuItem("部门基本信息查询");
		menu4.add(item7);
		menu4.add(item8);
		item9=new JMenuItem("帮助");
		item10=new JMenuItem("关于");
		menu5.add(item9);
		menu5.add(item10);
		menuBar.setVisible(true);
		
	}
	public void gj() {
		JToolBar toolBar = new JToolBar(); 
		JButton ambtn,asbtn,tmbtn,dmbtn,help,about; 
		ambtn=new JButton(new ImageIcon("res/card.png"));
		asbtn=new JButton(new ImageIcon("res/folder.png"));
		tmbtn=new JButton(new ImageIcon("res/info.png"));
		dmbtn=new JButton(new ImageIcon("res/save.png"));
		help=new JButton(new ImageIcon("res/help.png"));
		about=new JButton(new ImageIcon("res/user.png"));
		toolBar.add(ambtn);
		toolBar.add(asbtn);
		toolBar.add(tmbtn);
		toolBar.add(dmbtn);
		toolBar.add(help);
		toolBar.add(about);
		this.add(toolBar,BorderLayout.NORTH);
	}
	public void tp() {
		banner=new ImageIcon("res/image.png");
		jLabel=new JLabel(banner);
		panel1=new JPanel();
		panel1.add(jLabel);
		this.add(panel1,BorderLayout.CENTER);
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new ResearchMain();
		
	}

	/** * 通过给定的文件名获得图像 */
	
	Image getImage(String filename){ 
		//URLClassLoader--用于从指向 jar文件和目录的 URL 的搜索路径加载类和资源。
		URLClassLoader urlLoader=(URLClassLoader) this.getClass().getClassLoader(); 
		
		URL url=null; 
		Image image=null;
		url=urlLoader.findResource(filename); 
		image=Toolkit.getDefaultToolkit().getImage(url); 
		MediaTracker mediaTracker=new MediaTracker(this); 
		 try { 
			 mediaTracker.addImage(image, 0); 
			 mediaTracker.waitForID(0); 
		 }catch (InterruptedException _ex){
			 image=null;
		 }
		 if (mediaTracker.isErrorID(0)) {
			 image=null;
		 }
		 return image;
	}
	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		Object obj=e.getSource();
		if (obj==item2) {
			System.exit(0);
		}
		
	}
	public void addListener() {
		item2.addActionListener(this);
	}
	
}

eclipse快速生成set get方法以及构造方法

Thu, 17 Aug 2017 16:59:13 +0800

在eclipse中按快捷键 alt + shift + s 选择generate constructor using fields。然后在弹出框中选择成员变量即可快速创建构造方法。

生成set get方法：

在合适的地方采用快捷键 Shift+Alt+S

选择红框中的Generate Getter and Setter再选择需要实现get、set的参数

eclipse快捷键大全

Wed, 16 Aug 2017 20:21:43 +0800

1 几个最重要的快捷键

代码助手:Ctrl+Space（简体中文操作系统是Alt+/）
快速修正：Ctrl+1
单词补全：Alt+/
打开外部Java文档：Shift+F2

显示搜索对话框：Ctrl+H
快速Outline：Ctrl+O
打开资源：Ctrl+Shift+R
打开类型：Ctrl+Shift+T
显示重构菜单：Alt+Shift+T

上一个/下一个光标的位置：Alt+Left/Right
上一个/下一个成员（成员对象或成员函数）：Ctrl+Shift+Up/Down
选中闭合元素：Alt+Shift+Up/Down/Left/Right
删除行：Ctrl+D
在当前行上插入一行：Ctrl+Shift+Enter
在当前行下插入一行： Shift+Enter
上下移动选中的行：Alt+Up/Down

组织导入：Ctrl+Shift+O

2 定位

2.1 行内定位

行末/行首：End/Home
前一个/后一个单词：Ctrl+Right/Left

2.2 文件内定位

跳到某行：Ctrl+L
上下滚屏：Ctrl+Up/Down
上一个/下一个成员（成员对象或成员函数）：Ctrl+Shift+Up/Down
快速Outline：Ctrl+O

2.3 跨文件定位

打开声明：F3
打开资源：Ctrl+Shift+R
打开类型：Ctrl+Shift+T
在workspace中搜索选中元素的声明：Ctrl+G
在workspace中搜索选中的文本：Ctrl+Alt+G
在workspace中搜索选中元素的引用：Ctrl+Shift+G
打开调用层次结构：Ctrl+Alt+H
快速层次结构：Ctrl+T
反悔：Ctrl+Z

2.4 其它

上一个/下一个光标所在位置：Alt+Left/Right
上一个编辑的位置：Ctrl+Q

3 选中

3.1 行内选中

选中到行末/行首：Shift+End/Home
选中上一个/下一个单词：Ctrl+Shift+Left/Right

3.2 文件内选中

选中闭合元素：Alt+Shift+Up
恢复到上一个选中：Alt+Shift+Down
选中下一个/上一个元素：Alt+Shift+Right/Left

4 定位/选中/操作同时

删除行：Ctrl+D
删除下一个/上一个单词：Ctrl+Delete/Backspace
删除到行末：Ctrl+Shift+Delete
在当前行上插入一行：Ctrl+Shift+Enter
在当前行下插入一行： Shift+Enter
上下移动选中的行：Alt+Up/Down
拷贝选中的行：Ctrl+Alt+Up/Down

5 其它的代码编辑类快捷键

保存：Ctrl+S
保存所有：Ctrl+Shift+S
下一个命中的项（搜索之后）：Ctrl+.
注释：Ctrl+/
添加导入：Ctrl+Shift+M
显示快捷键帮助：Ctrl+Shift+L
变为大/小写：Ctrl+Shift+X/Y

6 重构

显示重构菜单：Alt+Shift+T
重构-改变方法签名：Alt+Shift+C
重构-移动：Alt+Shift+V
重构-重命名：Alt+Shift+R

7 编辑器、视图、透视图切换

下一个编辑器：Ctrl+F6
下一个视图：Ctrl+F7
下一个透视图：Ctrl+F8
最大化当前视图或编辑器：Ctrl+M
激活编辑器：F12

8 Debug

F5：Step Into（debug）
F6：Step over（debug）
F7：Step return（debug）
F8：Resume（debug）
F11：debug上一个应用（debug）

9 Up/Down/Right/Left类快捷键

Ctrl
前一个/后一个单词：Ctrl+Right/Left
上下滚屏：Ctrl+Up/Down

Alt
上一个/下一个光标的位置：Alt+Left/Right
上下移动选中的行：Alt+Up/Down
Shift
选中上一个/下一个字符：Shift+Left/Right
选中上一行/下一行（从当前光标位置开始）：Shift+Up/Down

Ctrl+Shift
上一个/下一个成员（成员对象或成员函数）：Ctrl+Shift+Up/Down
选中上一个/下一个单词：Ctrl+Shift+Left/Right

Alt+Shift
选中闭合元素：Alt+Shift+Up
恢复到上一个选中：Alt+Shift+Down
选中下一个/上一个元素：Alt+Shift+Right/Left
拷贝选中的行：Ctrl+Alt+Up/Down

Ctrl+Alt
拷贝选中的行：Ctrl+Alt+Up/Down

10 F类快捷键

F2：显示提示/重命名
F3：打开选中元素的声明
F4：打开选中元素的类型继承结构
F5：刷新
F5：Step Into（debug）
F6：Step over（debug）
F7：Step return（debug）
F8：Resume（debug）
F11：debug上一个应用（debug）
F12：激活编辑器

补充：

Ctrl+1 快速修复(最经典的快捷键,就不用多说了)
Ctrl+D: 删除当前行
Ctrl+Alt+↓ 复制当前行到下一行(复制增加)
Ctrl+Alt+↑ 复制当前行到上一行(复制增加)
Alt+↓ 当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴了)
Alt+↑ 当前行和上面一行交互位置(同上)
Alt+← 前一个编辑的页面
Alt+→ 下一个编辑的页面(当然是针对上面那条来说了)
Alt+Enter 显示当前选择资源(工程,or 文件 or文件)的属性
Shift+Enter 在当前行的下一行插入空行(这时鼠标可以在当前行的任一位置,不一定是最后)
Shift+Ctrl+Enter 在当前行插入空行(原理同上条)
Ctrl+Q 定位到最后编辑的地方
Ctrl+L 定位在某行 (对于程序超过100的人就有福音了)
Ctrl+M 最大化当前的Edit或View (再按则反之)
Ctrl+/ 注释当前行,再按则取消注释
Ctrl+O 快速显示 OutLine
Ctrl+T 快速显示当前类的继承结构
Ctrl+W 关闭当前Editer
Ctrl+K 参照选中的Word快速定位到下一个
Ctrl+E 快速显示当前Editer的下拉列表(如果当前页面没有显示的用黑体表示)
Ctrl+/(小键盘) 折叠当前类中的所有代码
Ctrl+×(小键盘) 展开当前类中的所有代码
Ctrl+Space 代码助手完成一些代码的插入(但一般和输入法有冲突,可以修改输入法的热键,也可以暂用Alt+/来代替)
Ctrl+Shift+E 显示管理当前打开的所有的View的管理器(可以选择关闭,激活等操作)
Ctrl+J 正向增量查找(按下Ctrl+J后,你所输入的每个字母编辑器都提供快速匹配定位到某个单词,如果没有,则在stutes line中显示没有找到了,查一个单词时,特别实用,这个功能Idea两年前就有了)
Ctrl+Shift+J 反向增量查找(和上条相同,只不过是从后往前查)
Ctrl+Shift+F4 关闭所有打开的Editer
Ctrl+Shift+X 把当前选中的文本全部变味小写
Ctrl+Shift+Y 把当前选中的文本全部变为小写
Ctrl+Shift+F 格式化当前代码
Ctrl+Shift+P 定位到对于的匹配符(譬如{}) (从前面定位后面时,光标要在匹配符里面,后面到前面,则反之)

MySQL多关键字多字段模糊查询

Wed, 16 Aug 2017 20:18:48 +0800

sql="select *,teacher.teacherID as teacherName, "
					+ "department.depID as depName "
					+ "from teacher,article,department "
					+ "where teacher.teacherID=article.teacherID and department.depID=article.depID and articleName like '%"+f2+"%' "//查询关键字
					+ "and teacherName like '%"+f3+"%' "
					+ "and year like '%"+f6+"%' "
					+ "and depName like '%"+f9+"%' "
					+ "order by articleID";

Java判断两个汉字是否相等

Tue, 15 Aug 2017 19:01:04 +0800

今天试了下用if语句判断两个汉字是否相等结果两个相等的汉字也会else 从网上查了查用下面语句不会出错：

String str1 = new String("");
String str2 = new String("");
str1.equals(str2)(相等时为true)
或str1.compareTo(str2)（只有在.equals()返回true时才为0）

科研信息管理系统---论文信息管理（及修改，删除，增加，查询为一体）

Tue, 15 Aug 2017 18:59:24 +0800

	package com.jnzyjsxy.node1;

	import java.awt.BorderLayout;
	import java.awt.Dimension;
	import java.awt.Font;
	import java.awt.GridBagConstraints;
	import java.awt.GridBagLayout;
	import java.awt.Insets;
	import java.awt.event.ActionEvent;
	import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;

import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JLabel;
	import javax.swing.JOptionPane;
	import javax.swing.JPanel;
	import javax.swing.JScrollPane;
	import javax.swing.JTable;
	import javax.swing.JTextField;
	import javax.swing.ListSelectionModel;
	import javax.swing.event.ListSelectionEvent;
	import javax.swing.event.ListSelectionListener;

import com.jnzyjsxy.common.ArticleBean;
import com.jnzyjsxy.common.Department;
import com.jnzyjsxy.common.TeacherBean;
//import com.jnzyjsxy.common.HistrinBeanb;
	//import com.jnzyjsxy.common.PersonBean;
	import com.jnzyjsxy.test.KyMain;
import com.jnzyjsxy.test.text;

	/*
	 * 人员删除管理
	 */
	public class Node11Panel extends JPanel implements ListSelectionListener,ActionListener,ItemListener{

		//创建上中下面板
		JPanel upPanel =new JPanel();
		JPanel centerPanel=new JPanel();
		JPanel downpanel =new JPanel();
		//定义图形界面元素
		String DeptID="1";//部门编号
		String teacher="1";
		JComboBox jComboBox11=null;//显示人员所在部门
		JComboBox jComboBox12=null;//显示人员所在部门
		JLabel jLabel=new JLabel();
		JLabel jLabel1=new JLabel();
		JLabel jLabel2=new JLabel();
		JLabel jLabel3=new JLabel();
		JLabel jLabel4=new JLabel();
		JLabel jLabel5=new JLabel();
		JLabel jLabel6=new JLabel();
		JLabel jLabel7=new JLabel();
		JLabel jLabel8=new JLabel();
		JLabel jLabel9=new JLabel();
		JLabel jLabel10=new JLabel();
		JLabel jLabel11=new JLabel();
		//JLabel jLabel3=new JLabel();
		
		JTextField jTextField1=new JTextField(15);
		JTextField jTextField2=new JTextField(15);
		JTextField jTextField3=new JTextField(15);
		JTextField jTextField4=new JTextField(15);
		JTextField jTextField5=new JTextField(15);
		JTextField jTextField6=new JTextField(15);
		JTextField jTextField7=new JTextField(15);
		JTextField jTextField8=new JTextField(15);
		JTextField jTextField9=new JTextField(15);
		JTextField jTextField10=new JTextField(15);
		JTextField jTextField11=new JTextField(15);
		
		JButton hq=new JButton();
		JButton addInfo=new JButton();
		JButton modifyInfo=new JButton();
		JButton deleteInfo=new JButton();
		JButton clearInfo=new JButton();
		
		
		JScrollPane jScrollPane1;
		JScrollPane jScrollPane2;
		
		//创建网格包布局对象
		GridBagLayout girdBag=new GridBagLayout();
		//创建网格包约束类变量
		GridBagConstraints girdBagCon;
		
		//定义表格变量
		JTable jTable;
		//ListSelectionModel列表选中模式类 用于设置JTable中记录选中的模式
		ListSelectionModel ListSelectionModel=null;
		//字符数组 存储列明 对应person 列名
		String[] colName={"编号","题目","作者","期刊/出版社","级别","发表时间","第几期","字数","部门编号","统计日期","备注"};
		//二维数组 存储每一行的记录纸行存储记录编号 列存储该记录各列值
		String[][] colValue;
		GridBagLayout girBag =new GridBagLayout();
		GridBagConstraints gridBagCon;
		
		
		//构造方法
		public Node11Panel() {
			// TODO Auto-generated constructor stub
			this.setLayout(new BorderLayout());//边框布局
			try {
				upInit();//上
				centenInit();
				//panelInit panelInit=new panelInit();
				//this.add(panelInit,BorderLayout.CENTER);//中
				//downInit();//下
				addListener();//监听
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}
		//上布局
		public void upInit() {
			//创建人员数据操作类 以便调用该类方法
			ArticleBean bean=new ArticleBean();
			//上部采用网格包不几乎 放置人员信息删除标签和包含表格的滚动面板
			upPanel.setLayout(girBag);
			try {
				//在上部添加标签 
				jLabel.setText("论文信息管理");
				jLabel.setFont(new Font("Dialog", 0, 16));
				gridBagCon=new GridBagConstraints();
				gridBagCon.gridx=0;
				gridBagCon.gridy=0;
				//外部填充 4个参数 top,left,bottom,right
				//既外部间距
				gridBagCon.insets=new Insets(0, 10, 0, 10);
				girBag.setConstraints(jLabel, gridBagCon);
				upPanel.add(jLabel);
				
				//调用Person类的searchAll 方法 获取所有的人员记录
				colValue=bean.searchAllForNode();
				//初始化表对象 2个参数 下面是JTable的构造
				//JTable(Object[][] rowData, Object[] columnNames) 
				 // 构造一个 JTable 来显示二维数组 rowData 中的值，其列名称为 columnNames
				//即第1个参数二维数组存储每一行的值，第2个参数一维数组存放列名称 
				jTable=new JTable(colValue,colName);
				//设置表的大小
				jTable.setPreferredScrollableViewportSize(new Dimension(750,350));
				//初始化表格选择模式对象
				ListSelectionModel=jTable.getSelectionModel();
				//设置表格为单选模式
				ListSelectionModel.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
				//添加选择监听事件
				ListSelectionModel.addListSelectionListener(this);
				//把表格放进滚动栏 
				jScrollPane1=new JScrollPane(jTable);
				//设置滚动面板大小
				jScrollPane1.setPreferredSize(new Dimension(750, 350));
				//把滚动面板放在标签的下面
				gridBagCon=new GridBagConstraints();
				gridBagCon.gridx=0;
				gridBagCon.gridy=1;
				gridBagCon.insets=new Insets(0, 0, 0, 0);
				girBag.setConstraints(jScrollPane1, gridBagCon);
				upPanel.add(jScrollPane1);
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
			//添加上部面板
			this.add(upPanel,BorderLayout.NORTH);
		}
		//中部面板
		
		public void centenInit() throws Exception{
			//中间放组件的面板 采用网格包布局
			centerPanel.setLayout(girdBag);
			//第一行组件
			//griy=1 实际的第二行 显示4个组件 gridx依次增加
			jLabel1.setText("论文编号");
			jLabel1.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=0;
			girdBagCon.gridy=1;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(0, 10, 10, 1);
			girdBag.setConstraints(jLabel1, girdBagCon);
			centerPanel.add(jLabel1);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=1;
			girdBagCon.gridy=1;
			girdBagCon.insets=new Insets(0, 1, 10, 15);
			girdBag.setConstraints(jTextField1, girdBagCon);
			centerPanel.add(jTextField1);
			
			jLabel2.setText("论文题目");
			jLabel2.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=2;
			girdBagCon.gridy=1;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(0, 15, 10, 1);
			girdBag.setConstraints(jLabel2, girdBagCon);
			centerPanel.add(jLabel2);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=3;
			girdBagCon.gridy=1;
			girdBagCon.insets=new Insets(0, 1, 10, 10);
			girdBag.setConstraints(jTextField2, girdBagCon);
			centerPanel.add(jTextField2);
			
			jLabel3.setText("作者");
			jLabel3.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=4;
			girdBagCon.gridy=1;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, 1);
			girdBag.setConstraints(jLabel3, girdBagCon);
			centerPanel.add(jLabel3);
			
			TeacherBean teacherBean=new TeacherBean();
			String[] alltype=teacherBean.searchAllForNode();
			//jComboBox11.setPreferredSize(new Dimension(125, 25));
			jComboBox11=new JComboBox(alltype);
			
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=5;
			girdBagCon.gridy=1;
			girdBagCon.insets=new Insets(10, 1, 10, 15);
			girdBag.setConstraints(jComboBox11, girdBagCon);
			centerPanel.add(jComboBox11);
			
			jLabel4.setText("期刊名称");
			jLabel4.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=0;
			girdBagCon.gridy=2;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 15, 10, 1);
			girdBag.setConstraints(jLabel4, girdBagCon);
			centerPanel.add(jLabel4);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=1;
			girdBagCon.gridy=2;
			girdBagCon.insets=new Insets(10, 1, 10, 10);
			girdBag.setConstraints(jTextField4, girdBagCon);
			centerPanel.add(jTextField4);
			
			jLabel5.setText("级别");
			jLabel5.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=2;
			girdBagCon.gridy=2;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, 1);
			girdBag.setConstraints(jLabel5, girdBagCon);
			centerPanel.add(jLabel5);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=3;
			girdBagCon.gridy=2;
			girdBagCon.insets=new Insets(10, 1, 10, 15);
			girdBag.setConstraints(jTextField5, girdBagCon);
			centerPanel.add(jTextField5);
			
			jLabel6.setText("发表年份");
			jLabel6.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=4;
			girdBagCon.gridy=2;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 15, 10, 1);
			girdBag.setConstraints(jLabel6, girdBagCon);
			centerPanel.add(jLabel6);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=5;
			girdBagCon.gridy=2;
			girdBagCon.insets=new Insets(10, 1, 10, 10);
			girdBag.setConstraints(jTextField6, girdBagCon);
			centerPanel.add(jTextField6);
			
			//第四行显示组件 gridy=4 gridx 依次增加
			jLabel7.setText("刊期");
			jLabel7.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=0;
			girdBagCon.gridy=3;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, 1);
			girdBag.setConstraints(jLabel7, girdBagCon);
			centerPanel.add(jLabel7);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=1;
			girdBagCon.gridy=3;
			girdBagCon.insets=new Insets(10, 1, 10, 10);
			girdBag.setConstraints(jTextField7, girdBagCon);
			centerPanel.add(jTextField7);
			
			jLabel8.setText("字数");
			jLabel8.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=2;
			girdBagCon.gridy=3;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, 1);
			girdBag.setConstraints(jLabel8, girdBagCon);
			centerPanel.add(jLabel8);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=3;
			girdBagCon.gridy=3;
			girdBagCon.insets=new Insets(10, 1, 10, 10);
			girdBag.setConstraints(jTextField8, girdBagCon);
			centerPanel.add(jTextField8);
			
			jLabel9.setText("所在系部");
			jLabel9.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=4;
			girdBagCon.gridy=3;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, 1);
			girdBag.setConstraints(jLabel9, girdBagCon);
			centerPanel.add(jLabel9);
			
			Department department=new Department();
			String[] s=department.searchAllForNode();
			//jComboBox12.setPreferredSize(new Dimension(125, 25));
			jComboBox12=new JComboBox(s);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=5;
			girdBagCon.gridy=3;
			girdBagCon.insets=new Insets(10, 1, 10, 10);
			girdBag.setConstraints(jComboBox12, girdBagCon);
			centerPanel.add(jComboBox12);
			
			jLabel10.setText("录入日期");
			jLabel10.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=0;
			girdBagCon.gridy=4;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, 1);
			girdBag.setConstraints(jLabel10, girdBagCon);
			centerPanel.add(jLabel10);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=1;
			girdBagCon.gridy=4;
			girdBagCon.insets=new Insets(10, 1, 10, 10);
			girdBag.setConstraints(jTextField10, girdBagCon);
			centerPanel.add(jTextField10);
			
			
			jLabel11.setText("备注");
			jLabel11.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=2;
			girdBagCon.gridy=4;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, 1);
			girdBag.setConstraints(jLabel11, girdBagCon);
			centerPanel.add(jLabel11);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=3;
			girdBagCon.gridy=4;
			girdBagCon.insets=new Insets(10, 1, 10, 10);
			girdBag.setConstraints(jTextField11, girdBagCon);
			centerPanel.add(jTextField11);
			
			
			//定义部门操作类
			//DeptBean dBean=new DeptBean();
			//调用方法获取所有部门的字符串
			//String[] alltype=dBean.searchAllForNode();
			//jComboBox1=new JComboBox(alltype);
			
			//girdBagCon=new GridBagConstraints();
			//girdBagCon.gridx=1;
			//girdBagCon.gridy=4;
			//girdBagCon.gridwidth=3;
			//girdBagCon.gridheight=1;
			//girdBagCon.insets=new Insets(10, 1, 10, 15);
			//girdBag.setConstraints(jComboBox1, girdBagCon);
			//centerPanel.add(jComboBox1);
						
			hq.setText("获取新编号");
			hq.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=0;
			girdBagCon.gridy=5;
			girdBagCon.gridwidth=2;
			girdBagCon.gridheight=1;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, 10);
			girdBag.setConstraints(hq, girdBagCon);
			centerPanel.add(hq);
			
			addInfo.setText("增加");
			addInfo.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=1;
			girdBagCon.gridy=5;
			girdBagCon.gridwidth=2;
			girdBagCon.gridheight=1;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, -100);
			girdBag.setConstraints(addInfo, girdBagCon);
			centerPanel.add(addInfo);
			
			modifyInfo.setText("修改");
			modifyInfo.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=2;
			girdBagCon.gridy=5;
			//girdBagCon.gridwidth=2;
			//girdBagCon.gridheight=1;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, -150);
			girdBag.setConstraints(modifyInfo, girdBagCon);
			centerPanel.add(modifyInfo);
			
			deleteInfo.setText("删除");
			deleteInfo.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=3;
			girdBagCon.gridy=5;
			//girdBagCon.gridwidth=2;
			//girdBagCon.gridheight=1;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, -150);
			girdBag.setConstraints(deleteInfo, girdBagCon);
			centerPanel.add(deleteInfo);
			
			deleteInfo.addActionListener((ActionListener) this);
			
			
			clearInfo.setText("清空");
			clearInfo.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=4;
			girdBagCon.gridy=5;
			//girdBagCon.gridwidth=2;
			//girdBagCon.gridheight=1;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, -170);
			girdBag.setConstraints(clearInfo, girdBagCon);
			centerPanel.add(clearInfo);
			this.add(centerPanel,BorderLayout.CENTER);

			jTextField1.setEditable(false);
			deleteInfo.setEnabled(false);
			modifyInfo.setEnabled(false);
			addInfo.setEnabled(false);
		}
		
		public void addListener() throws Exception{
			//删除按钮 活动监听
			deleteInfo.addActionListener(this);
			hq.addActionListener(this);
			addInfo.addActionListener(this);
			modifyInfo.addActionListener(this);
			clearInfo.addActionListener(this);
			jComboBox11.addItemListener(this);
			jComboBox12.addItemListener(new ItemListener() {
				
				@Override
				public void itemStateChanged(ItemEvent e) {
					// TODO Auto-generated method stub
					if (e.getStateChange()==ItemEvent.SELECTED)
					{
						//获取选中项目值，得到的是一个“1-办公室-秘书室”这样的字符串 
						//字符串构成：部门编号-一级部门-二级部门 
						System.out.println("321");
						String temStr=""+e.getItem();
						//返回指定子字符串"-"在此字符串中第一次出现处的索引 
						int i=temStr.indexOf("-");
						 //取部门id子字符串，目的是取前面的部门编号 
						DeptID=temStr.substring(0,i);
					}
					
				}
			});
		}
		public void actionPerformed(ActionEvent e) {
			// TODO Auto-generated method stub
			Object obj=e.getSource();
			ArticleBean art=new ArticleBean();
			if (obj==hq) {
				jTextField1.setText(Integer.toString(art.getId()));
				jTextField2.setText("");
				jTextField4.setText("");
				jTextField5.setText("");
				jTextField6.setText("");
				jTextField7.setText("");
				jTextField8.setText("");
				jTextField10.setText("");
				jTextField11.setText("");
				addInfo.setEnabled(true);
				deleteInfo.setEnabled(false);
				modifyInfo.setEnabled(false);
			}
	
			else if(obj==clearInfo) {
				jTextField1.setText("");
				jTextField2.setText("");
				jTextField4.setText("");
				jTextField5.setText("");
				jTextField6.setText("");
				jTextField7.setText("");
				jTextField8.setText("");
				jTextField10.setText("");
				jTextField11.setText("");
				deleteInfo.setEnabled(false);
				modifyInfo.setEnabled(false);
			}
			else if (obj==deleteInfo) {
				ArticleBean articleBean=new ArticleBean();
				articleBean.delete(jTextField1.getText());
				Node11Panel node13Panel=new Node11Panel();
				KyMain.splitPane.setRightComponent(node13Panel);
			} 
			else if (obj==addInfo) {
				
				
				art.add(jTextField2.getText(),teacher, jTextField4.getText(), jTextField5.getText(), jTextField6.getText(), jTextField7.getText(), jTextField8.getText(),DeptID,jTextField10.getText(), jTextField11.getText());
				
				Node11Panel node13Panel=new Node11Panel();
				KyMain.splitPane.setRightComponent(node13Panel);
			}
			else if (obj==modifyInfo) {
				art.modify(jTextField1.getText(), jTextField2.getText(), teacher, jTextField4.getText(), jTextField5.getText(), jTextField6.getText(), jTextField7.getText(), jTextField8.getText(), DeptID, jTextField10.getText(), jTextField11.getText());
				Node11Panel node13Panel=new Node11Panel();
				KyMain.splitPane.setRightComponent(node13Panel);
			}
			
			
			
			
			
			
				//重新生成界面 目的是删除记录后 显示删除后的剩余记录
				
				jTable.revalidate();//重新布局
	}
	
		@Override
		public void valueChanged(ListSelectionEvent e) {
			// TODO Auto-generated method stub
			//获取表选中的行的索引号
			int[] selecteRow=jTable.getSelectedRows();
			int[] selecteCol=jTable.getSelectedColumns();
			//定义文本框的现实内容
			//既在上面显示人员表中选中一条记录 下面上颚文本框中分别年是该记录的
			for (int i = 0; i < selecteRow.length; i++) {
				for (int j = 0; j < selecteCol.length; j++) {
					jTextField1.setText(colValue[selecteRow[i]][0]);
					jTextField2.setText(colValue[selecteRow[i]][1]);
					jTextField4.setText(colValue[selecteRow[i]][3]);
					jTextField5.setText(colValue[selecteRow[i]][4]);
					jTextField6.setText(colValue[selecteRow[i]][5]);
					jTextField7.setText(colValue[selecteRow[i]][6]);
					jTextField8.setText(colValue[selecteRow[i]][7]);
					jTextField10.setText(colValue[selecteRow[i]][9]);
					jTextField11.setText(colValue[selecteRow[i]][10]);
				}
			}
			deleteInfo.setEnabled(true);
			modifyInfo.setEnabled(true);
			hq.setEnabled(true);
			
		}
		public void itemStateChanged(ItemEvent e) {
			// TODO Auto-generated method stub
			//ItemEvent--项目事件，例如下拉列表框中项被选定或取消选定的事件 
			//e.getStateChange()--表示选定或取消选定 
			//ItemEvent.SELECTED--表示选定 
			//ItemEvent.DESELECTED--表示取消选定 
			//如果在下拉列表框中选中一个部门 
			//TeacherBean teacherBean=new TeacherBean();
			if (e.getStateChange()==ItemEvent.SELECTED)
			{
				//获取选中项目值，得到的是一个“1-办公室-秘书室”这样的字符串 
				//字符串构成：部门编号-一级部门-二级部门 
				System.out.println("123");
				String temStr=""+e.getItem();
				//返回指定子字符串"-"在此字符串中第一次出现处的索引 
				int i=temStr.indexOf("-");
				 //取部门id子字符串，目的是取前面的部门编号 
				teacher=temStr.substring(0,i);
			}
		}
	
	}

构建联合查询语句用于查询三联表中的数据

Mon, 14 Aug 2017 22:16:11 +0800

sql="select *,teacher.teacherID as teacherName, "
						+ "department.depID as depName "
						+ "from teacher,article,department "
						+ "where teacher.teacherID=article.teacherID and department.depID=article.depID "
			
						+ "order by articleID";

executeQueryUnknown column 'admin' in 'where clause' 解决办法

Mon, 14 Aug 2017 15:32:00 +0800

这个错误困扰了我两天啊因为这个错误所以做登陆界面的时候不是用的数据库所以也不能做注册修改

其实原因很简单而我得找了好几个小时都没有解决在测试的时候发现传递数字的时候可以返回记录到的字符串

而传递单词却无法返回就提示报错我觉着是数据库字符类型设计错了还是怎么得了百思不得解

接下来说明解决方法：

“select * from user where userName"=admin;

select * from user where userName=123

其实是因为执行sql查询语句的时候userName的值是数字所以不用加单引号而admin是英文所以要加上单引号

正确的应该是这样

sql="select * from user where userName='"+field2+"'";

在查询的字符串左右加上英文单冒号 ' '即可

在有main函数的前提下 eclipse找不到主类解决办法

Sun, 13 Aug 2017 21:49:23 +0800

有时候在测试类的时候eclipse会莫名奇妙的提示找不到主类接下来分别有几种解决办法

1.在项目上右击> Builder Path -> Configure Build Path -> 选择Source面板再点Add Folder, 把源代码所在的包路径的上层目录加进来，而且如果你是把两个类写在一个文件里的话,你在右键选择Run As Java Appication 的时候,要把光标至于包括main方法的类上

2复制粘贴带main函数的类创建一个新的类把代码复制进去即可ok

3 直接重建Java项目

如果还是不行在命令管理器上测试java是否正常运行如果没有看一下环境变量是否错误或者重新安装

login登陆界面设计

Sun, 13 Aug 2017 12:51:02 +0800

package com.jnzyjsxy.test;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class login extends Frame implements ActionListener {
TextField txtName;
TextField txtPassword;
Label lblTitle,lblName,lblPassword;
Button btnSubmit;
Button btnReset;

JButton clearInfo=new JButton();
static //创建网格包布局对象
GridBagLayout girdBag=new GridBagLayout();
//创建网格包约束类变量
GridBagConstraints girdBagCon;
public login(){
super("登陆界面");
//lblTitle=new Label("请输入您的用户信息:");
lblName=new Label("用户名:");
txtName=new TextField(15);
txtName.setFont(new Font("Dialog", 0, 15));
lblPassword=new Label("密码:");
txtPassword=new TextField(15);
txtPassword.setFont(new Font("Dialog", 0, 15));
txtPassword.setEchoChar('*');
btnSubmit=new Button("提交");
btnReset=new Button("重置");
//lblName.setText("用户名");

lblName.setFont(new Font("Dialog", 0, 16));
girdBagCon=new GridBagConstraints();
girdBagCon.gridx=0;
girdBagCon.gridy=1;
//外部填充 4个参数 top,left,bottom,right
//既外部间距
girdBagCon.insets=new Insets(0, 10, 10, 1);
girdBag.setConstraints(lblName, girdBagCon);
this.add(lblName);

girdBagCon=new GridBagConstraints();
girdBagCon.gridx=1;
girdBagCon.gridy=1;
girdBagCon.insets=new Insets(0, 1, 10, 15);
girdBag.setConstraints(txtName, girdBagCon);
this.add(txtName);

//lblPassword.setText("");
lblPassword.setFont(new Font("Dialog", 0, 16));
girdBagCon=new GridBagConstraints();
girdBagCon.gridx=0;
girdBagCon.gridy=2;
//外部填充 4个参数 top,left,bottom,right
//既外部间距
girdBagCon.insets=new Insets(0, 15, 10, 1);
girdBag.setConstraints(lblPassword, girdBagCon);
this.add(lblPassword);

girdBagCon=new GridBagConstraints();
girdBagCon.gridx=1;
girdBagCon.gridy=2;
girdBagCon.insets=new Insets(0, 1, 10, 15);
girdBag.setConstraints(txtPassword, girdBagCon);
this.add(txtPassword);

//addInfo.setText("增加");
btnSubmit.setFont(new Font("Dialog", 0, 16));
girdBagCon=new GridBagConstraints();
girdBagCon.gridx=0;
girdBagCon.gridy=3;
girdBagCon.gridwidth=2;
girdBagCon.gridheight=1;
//外部填充 4个参数 top,left,bottom,right
//既外部间距
girdBagCon.insets=new Insets(10, 10, 10, 90);
girdBag.setConstraints(btnSubmit, girdBagCon);
this.add(btnSubmit);

//clearInfo.setText("清空");
btnReset.setFont(new Font("Dialog", 0, 16));
girdBagCon=new GridBagConstraints();
girdBagCon.gridx=1;
girdBagCon.gridy=3;
girdBagCon.gridwidth=2;
girdBagCon.gridheight=1;
//外部填充 4个参数 top,left,bottom,right
//既外部间距
girdBagCon.insets=new Insets(10, 10, 10, -30);
girdBag.setConstraints(btnReset, girdBagCon);
this.add(btnReset);

this.btnSubmit.addActionListener(this);
this.btnReset.addActionListener(this);
addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public void actionPerformed(ActionEvent e){
String s=e.getActionCommand();
if(s.equals("重置")){
clear();
}else if(s.equals("提交")){
submit();
}else if(e.getSource()==txtName){
txtPassword.requestFocus();
}else if(e.getSource()==txtPassword){
submit();
}
}
public void clear(){
txtName.setText("");
txtPassword.setText("");
txtName.requestFocus();
}
public void submit(){
String n=txtName.getText();
String paw=txtPassword.getText();
if(n.equals("admin") && paw.equals("123")){
JOptionPane.showMessageDialog(this,"合法用户，欢迎进入本系统");
	HrP hrP=new HrP();
}else{
	
		JOptionPane.showMessageDialog(this, "非法用户，禁止进入本系统");
		System.exit(0);
		

}
}
public static void main(String[] args) {
	try {
		//UIManager--界面管理类
		//外观设置成所使用的操作平台的外观
		//即程序在哪个平台运行，显示的窗口，对话框将是哪个平台的外观
		UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
		login ttf=new login();
		ttf.setSize(300,200);
		//获取屏幕大小
				Dimension screenSize=Toolkit.getDefaultToolkit().getScreenSize();
				//获取当前项目的窗体大小
				Dimension frameSize=ttf.getSize();
				//如果项目窗体高>屏幕高，用屏幕高设置项目窗体高
				if (frameSize.height>screenSize.height) {
					frameSize.height=screenSize.height;
				}
				if (frameSize.width>screenSize.width) {
					frameSize.width=screenSize.width;
				}
		ttf.setLocation((screenSize.width-frameSize.width)/2,
				(screenSize.height-frameSize.height)/2);;
		ttf.setLayout(girdBag);
		 ttf.setResizable(false);
		ttf.setVisible(true);
		
	} catch (Exception e) {
		// TODO: handle exception
		e.printStackTrace();
	}
	//创建主类对象测试项目
	new login();

}

}

The project: Java which is referenced by the classpath, does not exist. 错误处理办法

Sat, 12 Aug 2017 21:18:29 +0800

在property-java build path-> project s tab把依赖去掉

转载自【 Java编程精选】SpringBoot (一) ：入门篇

Fri, 11 Aug 2017 20:08:20 +0800

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。用我的话来理解，就是spring boot其实不是什么新的框架，它默认配置了很多框架的使用方式，就像maven整合了所有的jar包，spring boot整合了所有的框架（不知道这样比喻是否合适）。

使用spring boot有什么好处
1）配置web.xml，加载spring和spring mvc
2）配置数据库连接、配置spring事务
3）配置加载配置文件的读取，开启注解
4）配置日志文件
…
配置完成之后部署tomcat 调试
…
现在非常流行微服务，如果我这个项目仅仅只是需要发送一个邮件，如果我的项目仅仅是生产一个积分；我都需要这样折腾一遍!
但是如果使用spring boot呢？
很简单，我仅仅只需要非常少的几个配置就可以迅速方便的搭建起来一套web项目或者是构建一个微服务！
快速入门
maven构建项目
1、访问https://start.spring.io/
2、选择构建工具Maven Project、Spring Boot版本1.3.6以及一些工程基本信息，点击“Switch to the full version.”java版本选择1.7，可参考下图所示：
3、点击Generate Project下载项目压缩包
4、解压后，使用eclipse，Import -> Existing Maven Projects -> Next ->选择解压后的文件夹-> Finsh，OK done!
项目结构介绍
另外，spingboot建议的目录结果如下：
root package结构：com.example.myproject

com

+- example

+- myproject

+- Application.java

|

+- domain

| +- Customer.java

| +- CustomerRepository.java

|

+- service

| +- CustomerService.java

|

+- controller

| +- CustomerController.java

|

1、Application.java 建议放到根目录下面,主要用于做一些框架配置
2、domain目录主要用于实体（Entity）与数据访问层（Repository）
3、service 层主要是业务类代码
4、controller 负责页面访问控制
采用默认配置可以省去很多配置，当然也可以根据自己的喜欢来进行更改
最后，启动Application main方法，至此一个java项目搭建好了！
引入web模块

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

@RestController

public class HelloWorldController {

@RequestMapping("/hello")

public String index() {

return "Hello World";

}

@RunWith(SpringJUnit4ClassRunner.class)

@SpringApplicationConfiguration(classes = MockServletContext.class)

@WebAppConfiguration

public class HelloWorldControlerTests {

private MockMvc mvc;

@Before

public void setUp() throws Exception {

mvc = MockMvcBuilders.standaloneSetup(new HelloWorldController()).build();

}

@Test

public void getHello() throws Exception {

mvc.perform(MockMvcRequestBuilders.get("/hello").accept(MediaType.APPLICATION_JSON))

.andExpect(MockMvcResultMatchers.status().isOk())

.andDo(MockMvcResultHandlers.print())

.andReturn();

}

开发环境的调试

<dependencies>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-devtools</artifactId>

<optional>true</optional>

</dependency>

</dependencies>

<build>

<plugins>

<plugin>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-maven-plugin</artifactId>

<configuration>

<fork>true</fork>

</configuration>

</plugin>

</plugins>

</build>

总结

转载自【Java编程精选】Java Web架构知识整理——记一次阿里面试经历

Thu, 10 Aug 2017 20:47:53 +0800

“你学习一门技术的最佳时机是三年前，其次是现在。”这话从来很灵验。经过这次面试，觉得需要整理下Java Web相关的资料，以便自己提高或者更快适应可能面临的新的工作。

首先谈谈Java Web需要掌握哪些东西。这里是一些知识点的搜集，暂不做详细说明，欢迎各位博友补充指正。

1.底层

Java语言相关的就不说了，首先是JVM的结构和工作原理。比较重要的是Java内存模型，各种GC算法，Classloader的加载原理等。个人对底层的一些东西还算比较了解，所以不过多纠结，实际上程序编译链接过程以及二进制文件的处理还是很值得研究的。
JVM监控及调优。作为一个开发人员并不一定需要非常熟悉JVM调优的方法，但如果具备JVM监控及调优的能力，将让你对程序运行状况了如指掌，对于问题定位也会敏感得多。
Java多线程。对于线程安全的理解，以及如何在自己的程序中避免多线程造成的不一致问题等。
I/O。Java中常常提到的是BIO/NIO，即阻塞型I/O与非阻塞型I/O，其实并不难理解，结合Linux中的同步I/O和异步I/O的实现原理，基本都是相通的，每种I/O方式解决的问题，又存在什么问题，为什么使用epoll。

2.Servlet

Servlet是运行于服务端的java程序，一般实现自己的Java服务端应用都从HttpServlet类继承，然后实现自己的init | doGet | doPost | service方法。Servlet的生命周期从其加载开始，首先执行一次初始化，调用init方法，之后便可运行自身的服务，当生命周期结束时，调用destroy方法回收资源，结束服务。

仅了解原理当然是不够的，还要实战能力，在IDE中写写简单的代码谁都会，然而真正让一个程序能够运行起来也还需要点其他的东西，这里我指的是Servlet的容器。servlet的容器有很多，常用的以Tomcat为例，安装好Tomcat后，在开发时必须包含进Tomcat的lib。IDE确实惯坏了好多人，目录如何组织，程序如何编译、如何部署这些问题都被IDE屏蔽掉了，如果要对整体有比较透彻的了解，建议一切从命令行动手。

具体可参考：《Servlet与JSP核心编程》。

3.框架

Java Web开发的用到的框架之多简直令人发指，而且因为版本的更新换代导致的问题也是层出不穷。然而这也是Web技术不断演化的结果，要么选择接受，要么引领节奏。

Spring

Spring是一个强大而又“轻量级”的Java开发框架，之所以打引号是因为感觉并不是那么轻量。Spring的主要目的在于简化Java应用开发，以配置方式代替硬编码方式的编程，模块解耦，其架构如下图所示。包括了数据访问、远程通信、AOP、核心容器等部分。

Figure 1 Spring体系架构

Spring的核心主要有三点：

IoC：反转控制。

反转控制就是指将控制权由类内部抽离到容器，由容器类的实例化及动作进行配置管理。

Dependency-injection：依赖注入

对象的依赖关系由负责协调系统中各个对象的第三方组件在创建对象时设定。对象不自行创建或管理它们的依赖关系，依赖关系被自动注入到需要它们的对象中。通过参数和配置能够体会出“注入”这个词在这里有多形象。依赖注入的最大好处就是松耦合。不需要再类内部去和特定的类进行绑定，而是将一些依赖关系以参数的形式注入到类内部。

Aspect Oriented Programming：面向切向编程

在软件开发中，分布于应用中多处的功能被称为横切关注点。这些横切关注点往往和业务逻辑是相分离的，将这些横切关注点与业务逻辑相分离正式AOP要解决的。AOP编程能够让遍布在应用各处的功能分离出来形成可重用的组件。是高内聚低耦合的又一个体现，将通用实现模块与核心业务模块相分离。

具体参考：《Spring In Action》

Hibernate

数据持久化框架其实也有很多，需要掌握的不仅是Hibernate，只是因为Hibernate在以前的企业级应用中用的比较多而已，另外MyBatis也占有相当重要的份额。Hibernate是一个全自动的持久化框架，并不是那么方便，所以很多开发者更倾向于使用MyBatis，淘宝就是这样。

Hibernate的工作流程：首先通过configuration对象读取配置文件；解析映射信息，创建StandardSessionFactory；调用openSession打开session；创建事务transaction，之后进行持久化操作；完成后提交事务，关闭session，关闭sessionFactory。

Figuer 2 Hibernate工作流程

要理解ORM的理念：ORM意为对象关系映射。是一种为了解决程序的面向对象模型与数据库关系模型互不匹配问题的技术。

hibernate中比较重要的是对象的4种状态转换及条件。分别是transient瞬时态、persistent持久态、detached游离态和移除态，状态转换如下：

Figure 3 Hibernate对象状态转换图

Struts 2

Node11Panel类添加人员信息操作

Tue, 08 Aug 2017 19:16:47 +0800

package com.jnzyjsxy.node1;

import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;

import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextField;

import com.jnzyjsxy.common.DeptBean;
import com.jnzyjsxy.common.PersonBean;
import com.jnzyjsxy.test.HrMain;

/*
 * 第一个节点
 * 添加人员信息
 */
public class Node11Panel extends JPanel implements ActionListener,ItemListener{
	
	//创建两个面板 一个中间面板 一个上部面板
	JPanel centerPanel=new JPanel();
	JPanel upPanel=new JPanel();
	//定义图形元素
	JLabel jLabel = new JLabel();
	JLabel jLabel1 = new JLabel();
	JLabel jLabel2 = new JLabel();
	JLabel jLabel3 = new JLabel();
	JLabel jLabel4 = new JLabel();
	JLabel jLabel5 = new JLabel();
	JLabel jLabel6 = new JLabel();
	JLabel jLabel7 = new JLabel();
	JLabel jLabel8 = new JLabel();
	JLabel jLabel9 = new JLabel();
	
	JTextField jTextField1 =new JTextField(15);//编号
	JTextField jTextField2 =new JTextField(15);//姓名
	JTextField jTextField3 =new JTextField(15);//性别
	JTextField jTextField4 =new JTextField(15);//出生年月
	JTextField jTextField5 =new JTextField(15);//民族
	JTextField jTextField6 =new JTextField(15);//地址
	
	JComboBox jComboBox1=null;//显示人员所在部门
	String DeptID="1";//部门编号
	String Salary="0";//薪酬
	String Assess="未考核";//考核
	//用于输入其他字段值
	JTextField jTextField8=new JTextField(15);
	
	JScrollPane jScrollPane;
	//创建按钮 本页面使用addInfo clearInfo 
	//为了实现页面复制 定义多个按钮 哪个页面需要 使用哪个按钮
	JButton addInfo=new JButton();
	JButton modifyInfo=new JButton();
	JButton deleteInfo=new JButton();
	JButton clearInfo=new JButton();
	//创建网格包布局对象
	GridBagLayout girdBag=new GridBagLayout();
	//创建网格包约束类变量
	GridBagConstraints girdBagCon;
	//创建PersonBean 人员数据操作类
	PersonBean bean=new PersonBean();
	
	public Node11Panel() {
		// TODO Auto-generated constructor stub
		//采用边框布局
		this.setLayout(new BorderLayout());
		try {
			jscrollPanelInit();//上部面板初始
			panelInit();//中间面板初始化
			addListener();//监听事件方法
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}
	/*
	 * jscrollpanel 面板的布局 包含放置组件的中间面板centerPanel
	 * (non-Javadoc)
	 * @see java.awt.event.ItemListener#itemStateChanged(java.awt.event.ItemEvent)
	 */
	public void jscrollPanelInit() {
		//中间放组件的面板 采用网格包布局
		centerPanel.setLayout(girdBag);
		//第一行组件
		//griy=1 实际的第二行 显示4个组件 gridx依次增加
		jLabel1.setText("人员编号");
		jLabel1.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=1;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(0, 10, 10, 1);
		girdBag.setConstraints(jLabel1, girdBagCon);
		centerPanel.add(jLabel1);
		
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=1;
		girdBagCon.gridy=1;
		girdBagCon.insets=new Insets(0, 1, 10, 15);
		girdBag.setConstraints(jTextField1, girdBagCon);
		centerPanel.add(jTextField1);
		
		jLabel2.setText("人员姓名");
		jLabel2.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=2;
		girdBagCon.gridy=1;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(0, 15, 10, 1);
		girdBag.setConstraints(jLabel2, girdBagCon);
		centerPanel.add(jLabel2);
		
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=3;
		girdBagCon.gridy=1;
		girdBagCon.insets=new Insets(0, 1, 10, 10);
		girdBag.setConstraints(jTextField2, girdBagCon);
		centerPanel.add(jTextField2);
		
		jLabel3.setText("性 别");
		jLabel3.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=2;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(10, 10, 10, 1);
		girdBag.setConstraints(jLabel3, girdBagCon);
		centerPanel.add(jLabel3);
		
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=1;
		girdBagCon.gridy=2;
		girdBagCon.insets=new Insets(10, 1, 10, 15);
		girdBag.setConstraints(jTextField3, girdBagCon);
		centerPanel.add(jTextField3);
		
		jLabel4.setText("出 生 年 月");
		jLabel4.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=2;
		girdBagCon.gridy=2;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(10, 15, 10, 1);
		girdBag.setConstraints(jLabel4, girdBagCon);
		centerPanel.add(jLabel4);
		
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=3;
		girdBagCon.gridy=2;
		girdBagCon.insets=new Insets(10, 1, 10, 10);
		girdBag.setConstraints(jTextField4, girdBagCon);
		centerPanel.add(jTextField4);
		
		jLabel5.setText("民		族");
		jLabel5.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=3;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(10, 10, 10, 1);
		girdBag.setConstraints(jLabel5, girdBagCon);
		centerPanel.add(jLabel5);
		
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=1;
		girdBagCon.gridy=3;
		girdBagCon.insets=new Insets(10, 1, 10, 15);
		girdBag.setConstraints(jTextField5, girdBagCon);
		centerPanel.add(jTextField5);
		
		jLabel6.setText("地		址");
		jLabel6.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=2;
		girdBagCon.gridy=3;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(10, 15, 10, 1);
		girdBag.setConstraints(jLabel6, girdBagCon);
		centerPanel.add(jLabel6);
		
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=3;
		girdBagCon.gridy=3;
		girdBagCon.insets=new Insets(10, 1, 10, 10);
		girdBag.setConstraints(jTextField6, girdBagCon);
		centerPanel.add(jTextField6);
		
		//第四行显示组件 gridy=4 gridx 依次增加
		jLabel7.setText("部		门");
		jLabel7.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=4;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(10, 10, 10, 1);
		girdBag.setConstraints(jLabel7, girdBagCon);
		centerPanel.add(jLabel7);
		
		//定义部门操作类
		DeptBean dBean=new DeptBean();
		//调用方法获取所有部门的字符串
		String[] alltype=dBean.searchAllForNode();
		jComboBox1=new JComboBox(alltype);
		
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=1;
		girdBagCon.gridy=4;
		//girdBagCon.gridwidth=3;
		//girdBagCon.gridheight=1;
		girdBagCon.insets=new Insets(10, 1, 10, 15);
		girdBag.setConstraints(jComboBox1, girdBagCon);
		centerPanel.add(jComboBox1);
				
		jLabel8.setText("其		他");
		jLabel8.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=2;
		girdBagCon.gridy=4;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(10, 0, 10, 1);
		girdBag.setConstraints(jLabel8, girdBagCon);
		centerPanel.add(jLabel8);
		
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=3;
		girdBagCon.gridy=4;
		girdBagCon.gridwidth=3;
		girdBagCon.gridheight=1;
		girdBagCon.insets=new Insets(10, 1, 10, 15);
		girdBag.setConstraints(jTextField8, girdBagCon);
		centerPanel.add(jTextField8);
		
		addInfo.setText("增加");
		addInfo.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=5;
		girdBagCon.gridwidth=2;
		girdBagCon.gridheight=1;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(10, 10, 10, 10);
		girdBag.setConstraints(addInfo, girdBagCon);
		centerPanel.add(addInfo);
		
		
		
		clearInfo.setText("清空");
		clearInfo.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=2;
		girdBagCon.gridy=5;
		girdBagCon.gridwidth=2;
		girdBagCon.gridheight=1;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(10, 10, 10, 10);
		girdBag.setConstraints(clearInfo, girdBagCon);
		centerPanel.add(clearInfo);

	}
	
	//上部面板初始化
	public void panelInit() {
		//上部面板，网格包布局
		upPanel.setLayout(girdBag);
		//上部包含泽增加人员信息标签和滚动面板
		jLabel.setText("增加人员信息");
		jLabel.setFont(new Font("Dialog", 0, 16));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=0;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(0, 10, 0, 10);
		girdBag.setConstraints(jLabel, girdBagCon);
		upPanel.add(jLabel);
		
		//滚动面板 包含组件的中间，面板在滚动面板上
		jScrollPane =new JScrollPane(centerPanel);
		jScrollPane.setPreferredSize(new Dimension(450,380));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=1;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(0, 0, 0, 0);
		girdBag.setConstraints(jScrollPane, girdBagCon);
		upPanel.add(jScrollPane);
		
		//上部面板添加到窗体
		this.add(upPanel,BorderLayout.NORTH);
		//设置人员编号文本框不可用
		jTextField1.setEditable(false);
		jTextField2.setEditable(true);
		jTextField3.setEditable(true);
		jTextField4.setEditable(true);
		jTextField5.setEditable(true);
		jTextField6.setEditable(true);
		jTextField8.setEditable(true);
		jTextField1.setText(""+bean.getId());
		
	}
	/*添加事件监听
	 * (non-Javadoc)
	 * @see java.awt.event.ItemListener#itemStateChanged(java.awt.event.ItemEvent)
	 */
	public void addListener() {
		//添加添加，清空按钮事件监听
		addInfo.addActionListener(this);
		clearInfo.addActionListener(this);
		//给显示部门的下拉列表添加项目选择监听
		//既当在下拉列表框中选择项目后 触发监听
		jComboBox1.addItemListener(this);
		
	}
	@Override
	public void itemStateChanged(ItemEvent e) {
		// TODO Auto-generated method stub
		//ItemEvent--项目事件，例如下拉列表框中项被选定或取消选定的事件 
		//e.getStateChange()--表示选定或取消选定 
		//ItemEvent.SELECTED--表示选定 
		//ItemEvent.DESELECTED--表示取消选定 
		//如果在下拉列表框中选中一个部门 
		if (e.getStateChange()==ItemEvent.SELECTED) {
			//获取选中项目值，得到的是一个“1-办公室-秘书室”这样的字符串 
			//字符串构成：部门编号-一级部门-二级部门 
			String temStr=""+e.getItem();
			//返回指定子字符串"-"在此字符串中第一次出现处的索引 
			int i=temStr.indexOf("-");
			 //取部门id子字符串，目的是取前面的部门编号 
			DeptID=temStr.substring(0,i);
		}
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		Object obj=e.getSource();
		if (obj==addInfo) {//增加
			//调用Personean的add()方法 实现添加纪录
			bean.add(jTextField1.getText(), jTextField2.getText(), jTextField3.getText(), jTextField4.getText(), jTextField5.getText(), jTextField6.getText(), DeptID, Salary, Assess, jTextField8.getText());
			//定义添加人员信息页面对象
			Node11Panel node11Panel=new Node11Panel();
			//用添加人员信息作为右侧组件
			HrMain.splitPane.setRightComponent(node11Panel);
		}
		else if (obj==clearInfo) {
			setNull();//调用清空方法
		}
	}
	void setNull(){
		jTextField2.setText(null);
		jTextField3.setText(null);
		jTextField4.setText(null);
		jTextField5.setText(null);
		jTextField6.setText(null);
		jTextField8.setText(null);
	}

}

系统运行主类HrP.java（包含main）和主界面类HrMain.java 1. 系统运行主类HrMS.java，包含main方法。

Tue, 08 Aug 2017 19:16:10 +0800

package com.jnzyjsxy.test;

import java.awt.Dimension;
import java.awt.Toolkit;

import javax.swing.UIManager;

/*
 * 人事管理运行主类
 */
public class HrP {
	//定义布尔型变量
	boolean packFame=false;
	//构造方法
	public HrP() {
		// TODO Auto-generated constructor stub
		//创建主窗体类对象
		HrMain frame=new HrMain();
		if (packFame) {
			//窗口自适应大小 使窗口正好显示里面的控件
			frame.pack();
		}else {
			//使用validate方法 会使容器再次布置其子控件
			frame.validate();
		}
		//获取屏幕大小
		Dimension screenSize=Toolkit.getDefaultToolkit().getScreenSize();
		//获取当前项目的窗体大小
		Dimension frameSize=frame.getSize();
		//如果项目窗体高>屏幕高，用屏幕高设置项目窗体高
		if (frameSize.height>screenSize.height) {
			frameSize.height=screenSize.height;
		}
		if (frameSize.width>screenSize.width) {
			frameSize.width=screenSize.width;
		}
		//设置窗体起始显示位置 居中显示
		frame.setLocation((screenSize.width-frameSize.width)/2,
		(screenSize.height-frameSize.height)/2);
		//显示窗体
		frame.setVisible(true);
	}
	public static void main(String[] args) {
		 //设置运行风格
		try {
			//UIManager--界面管理类
			//外观设置成所使用的操作平台的外观
			//即程序在哪个平台运行，显示的窗口，对话框将是哪个平台的外观
			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		//创建主类对象测试项目
		new HrP();
	}
}

HrMain.java系统主界面类，采用树形目录结构。

Tue, 08 Aug 2017 19:14:37 +0800

package com.jnzyjsxy.test;
import java.awt.AWTError;
import java.awt.AWTEvent;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Image;
import java.awt.MediaTracker;
import java.awt.Panel;
import java.awt.Toolkit;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.net.URL;
import java.net.URLClassLoader;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTree;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
/*

人事管理系统主界面
*/
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;

import com.jnzyjsxy.node1.Node11Panel;
public class HrMain extends JFrame implements TreeSelectionListener{
private static final URLClassLoader URLClassLoader = null;
//框架大小
Dimension faceSize=new Dimension(650, 450);
//程序图标
Image icon;
//建立JTree目录树对象
JTree tree;
//书数据结构中的通用节点
//字面含义，默认可变的树节点类
DefaultMutableTreeNode root;//人事管理系统根节点
DefaultMutableTreeNode node1;//基本信息管理
DefaultMutableTreeNode node2;//人员管理节点
DefaultMutableTreeNode node3;//人员考核管理
DefaultMutableTreeNode node4;//劳资管理
DefaultMutableTreeNode node5;//
DefaultMutableTreeNode leafnode;//二级节点
TreePath treePath;//节点路径类
//主界面面板
//JSplitPane 用于分割两个（只能是两个）Component
//两个Component图形化分割
//并且这两个Component可以由用户交互式调整大小
//split–分裂，拆分
public static JSplitPane splitPane;
JPanel panel1;//在左侧放目录树
JPanel panel2;
JPanel panel3;//在右侧显示选择节点后的界面
//用于显示欢迎信息的标签
JLabel welcome=new JLabel();
//滚动面板对象
JScrollPane scrollPane;
/*
* 构造方法(non-Javadoc)
* @see java.awt.Window#pack()
/public HrMain() {
// TODO Auto-generated constructor stub
//启动窗体事件隐藏 mask-面具，隐藏
//要是没有enableEvents(AWTEvent.WIDOW_EVENT_MASK);
//只要有addActionListener()方法，窗体也就拥有该方法
//本项目通过选择目录树触发活动事件
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
//添加框架的关闭时间处理
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//窗口自适应大小 使窗体能正好显示里面的所有控件
this.pack();
//设置框架的大小
this.setSize(faceSize);
//设置窗体的标题
this.setTitle(“人事管理系统”);
//调用自定义的方法GetImage（） ，获取图标文件
//icon=getImage(“common/icon.png”);
//设置窗体图标
this.setIconImage(icon);
//设置不能调整窗体的大小
this.setResizable(false);
try {
Init();//调用初始化方法
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
/
* 初始化方法 创建左侧菜单树
*/
private void Init() {
// TODO Auto-generated method stub
//初始化树形节点
root=new DefaultMutableTreeNode(“人事管理系统”);
node1=new DefaultMutableTreeNode(“基本信息管理”);
node2=new DefaultMutableTreeNode(“人员调动管理”);
node3=new DefaultMutableTreeNode(“人员考核管理”);
node4=new DefaultMutableTreeNode(“劳资管理”);
//添加基本信息管理节点到认识管里系统根节点
root.add(node1);
//添加耳机节点 并添加到基本信息管理一级节点上
leafnode=new DefaultMutableTreeNode(“添加人员信息”);
node1.add(leafnode);
leafnode=new DefaultMutableTreeNode(“修改人员信息”);
node1.add(leafnode);
leafnode=new DefaultMutableTreeNode(“删除人员信息”);
node1.add(leafnode);
leafnode=new DefaultMutableTreeNode(“查询人员信息”);
node1.add(leafnode);
leafnode=new DefaultMutableTreeNode(“部门管理”);
node1.add(leafnode);
//添加人员调动节点到根节点
root.add(node2);
leafnode=new DefaultMutableTreeNode(“人员调动”);
node2.add(leafnode);
leafnode=new DefaultMutableTreeNode(“调动历史查询”);
node2.add(leafnode);
root.add(node3);
leafnode=new DefaultMutableTreeNode(“人员考核”);
node3.add(leafnode);
leafnode=new DefaultMutableTreeNode(“考核历史查询”);
node3.add(leafnode);

外观设置成所使用的操作平台的外观即程序在哪个平台运行，显示的窗口，对话框将是哪个平台的外观

Mon, 07 Aug 2017 18:57:57 +0800

 //UIManager--界面管理类
			//外观设置成所使用的操作平台的外观
			//即程序在哪个平台运行，显示的窗口，对话框将是哪个平台的外观
			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

用于测试数据库连接情况

Mon, 07 Aug 2017 13:41:34 +0800

package com.jnzyjsxy.test;

import com.jnzyjsxy.common.Database;
import com.jnzyjsxy.common.DeptBean;
import com.jnzyjsxy.common.HistrinBean;
import com.jnzyjsxy.common.PersonBean;

public class Text {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//PersonBean personBean=new PersonBean();
		//personBean.add("7","庞玉栋", "男", "1998-1-19", "汉", "", "7", "1900.23", "优秀",null);
		//personBean.updateDept("5", "2000.0");
		//String[][] strings=personBean.searchAll();
		//System.out.println(strings[0][2]);
		//String f1 = "1";
		//personBean.delete(f1);
		//DeptBean deptBean=new DeptBean();
		//String[] strings=deptBean.search("7");
		//System.out.print(strings[0]+".");
		//System.out.print(strings[1]+".");
		//System.out.print(strings[2]);
		//System.out.println(deptBean.getDepstr("1"));
		HistrinBean histrinBean=new HistrinBean();
		String[] string=null;
		//histrinBean.add("13", "人员分配", "2", "4", "1", "1", "1");
		string=histrinBean.search("1");
		System.out.println(string[4]);
	}
	

}

”无法解析类型这是简介引用的类文件要求从必需的 .class 文件间接引用了“——解决方法

Sun, 06 Aug 2017 19:30:39 +0800

百度翻译：

在线程的“主”java.lang.error例外：解决编制问题：类型javax.swing.jcomponent不能解决。这是间接引用的类文件的要求。

该方法在类型数据库executeupdate()不适用于参数（字符串）方法showmessagedialog（组件对象）在型JOptionPane不适用于参数（null，String，int）

COM。jnzyjsxy。常见。personbean。<初始化>（personbean。java：53） COM。jnzyjsxy。测试。文字。主要（文本。java：13）

这个编译错误有几个原因：

1、jdk版本问题

要是报错是某些java包里的东西那就可以肯定是jdk版本的问题，

比如无法解析类型java.lang.Object，无法解析类型java.lang.CharSequence.

解决方法：换jdk版本或者重装jdk

2、maven依赖的jar包有问题

当maven项目引用jar包的时候，有些jar包会失效，导致这个问题。

解决方法：把maven本地库jar包删除重新下载，或者删除后换个仓库下载。

JDBC数据库连接代码

Sat, 05 Aug 2017 17:02:45 +0800

package com.jnzyjsxy.common;
import java.sql.DriverManager;
import java.sql.ResultSet;
import com.mysql.jdbc.Connection;
import com.mysql.jdbc.Statement;
/*

数据库连接类

*/
public class Database {
//创建成员变量用于存储数据库连接的字符串或结果
//statement接口 用于执行静态sql语句 并返回它所生成的结果
private Statement stmt=null;
//结果集类
ResultSet rs=null;
//链接类
private Connection conn=null;
String sql;//存储sql语句
//mysql数据连接字符串
//“jdbc:mysql://localhost:3306/db_hrms”
//数据库名称db_hrms
//在数据库名称后，增加"?characterEncoding=GBK"，避免插入记录为乱码
String strurl=“jdbc:mysql://localhost:3306/db_hrms?characterEncoding=GBK”;//主机地址
String username=“root”;//用户名
String password=“123456”;//密码
//构造方法
public Database(){
}
/*

打开数据库连接

*/
public void openConn() {
try {
Class.forName(“com.mysql.jdbc.Driver”);
//DriverManager.getConnection启动器管理类的连接方法
//创建数据库连接对象三个参数 初始化conn
conn=(Connection) DriverManager.getConnection(strurl, username, password);
System.out.println(“数据库连接成功”);
} catch (Exception e) {
// TODO: handle exception

关于Class.forName(“com.mysql.jdbc.Driver”)

Thu, 03 Aug 2017 17:14:46 +0800

传统的使用jdbc来访问数据库的流程为：
Class.forName(“com.mysql.jdbc.Driver”);
String url = “jdbc:mysql://localhost:3306/test?user=root&password=123456″;
Connection con = DriverManager.getConnection(url);
Statement statement = con.createStatement();

最开始使用的时候，不明白为什么首先要加载一个驱动类，之后就可以取得了Connection了，很好奇DriverManager是怎么获得那个驱动类的信息，后来看了下com.mysql.jdbc.Driver这个类的源代码，豁然开朗了。原来在com.mysql.jdbc.Driver类中有这么一段静态初始化代码：
static {
try {
java.sql.DriverManager.registerDriver(new Driver());
} catch (SQLException E) {
throw new RuntimeException(“Can’t register driver!”);
}
}
也就是，在Class.forName加载完驱动类，开始执行静态初始化代码时，会自动新建一个Driver的对象，并调用DriverManager.registerDriver把自己注册到DriverManager中去。

ps1: Class.forName(String) 与ClassLoader.loadClass(String)的区别
Class.forName(String): 加载类，并且执行类初始化；可以通过Class.forName(String, boolean, ClassLoader)第二个参数来仅仅加载类不执行初始化；
ClassLoader.loadClass(String): 仅仅加载类，不执行类初始化；

ps2: 有时会看到这种用法：
Class.forName(“com.mysql.jdbc.Driver”).newInstance();
这是没有必要的，正如前述，静态初始化已经new了一个Driver的对象，注册到DriverManager中去，在此再建立一个Driver对象则是完全没有必要的，浪费空间。

ps3: 结合ps1，Class.forName(“com.mysql.jdbc.Driver”);相当于：
ClassLoader loader = Thread.currentThread().getContextClassLoader();
Class cls = loader.loadClass(“com.mysql.jdbc.Driver”);
cls.newInstance();
这种方法的问题同ps2, 浪费了一个Driver对象；

ps4: 在java 6中，引入了service provider的概念，即可以在配置文件中配置service（可能是一个interface或者abstract class）的provider（即service的实现类）。配置路径是：/META-INF/services/下面。详细信息见：https://docs.oracle.com/javase/6/docs/technotes/guides/jar/jar.html#Service%20Provider
而java.sql.DriverManager也添加了对此的支持，因此，在JDK6中，DriverManager的查找Driver的范围为：
1）system property “jdbc.drivers” 中配置的Driver值；
2）用户调用Class.forName()注册的Driver
3）service provider配置文件java.sql.Driver中配置的Driver值。
因此，在jdk6中，其实是可以不用调用Class.forName来加载mysql驱动的，因为mysql的驱动程序jar包中已经包含了java.sql.Driver配置文件，并在文件中添加了com.mysql.jdbc.Driver.但在JDK6之前版本，还是要调用这个方法。

转载自【Java编程精选】20个非常有用的Java程序片段

Wed, 02 Aug 2017 19:26:36 +0800

下面是20个非常有用的Java程序片段，希望能对你有用。内容比较早，有些函数可能过时了，但是总体思路是不错滴，供参考。

1、字符串有整型的相互转换

String a = String.valueOf(2);   //integer to numeric string
int i = Integer.parseInt(a); //numeric string to an int

2、向文件末尾添加内容

BufferedWriter out = null;     try {         out = new BufferedWriter(new FileWriter(”filename”, true));         out.write(”aString”);     } catch (IOException e) {         // error processing code     
} finally {         if (out != null) {             out.close();         }     }

3、得到当前方法的名字

转载自【Java编程精选】给Java新手的一些建议----Java知识点归纳(J2EE and Web 部分)

Mon, 31 Jul 2017 15:33:12 +0800

　　我本人在JAVA开发刚入行的时候，也是做了不少web相关的项目，之后渐渐地web使用比较少了，现在web开发的技术日新月异，不过一些基础知识还是类似，所以也把这部分内容稍作整理，以期望可以给大家一些经验。

这次主要涉及到的两大块内容: Web相关的， J2EE相关的技术

Web部分:

HTTP协议，HTTPS协议

　　对于HTTP请求，我主要会关注以下内容:

HTTP请求的模式: request/response

HTTP请求的方法：GET， POST， PUT，DELETE 等等

协议的具体格式: head + body

协议的各类返回码:1XX，2XX，3XX，4XX，5XX

Header中一些主要属性的含义和使用场景

HTTPS协议

Cookie的基本原理和使用场景

HTML， CSS

JavaScript：

　　因为自己对这个涉猎也不深入，所以也就不更多罗列了，以免误人子弟了。

Webservice

　　Webservice的实现方式多种多样，两者共同点是大家都是以HTTP协议为基础的，都可以跨域，跨语言进行访问。

Java简介和安装教程

Sat, 29 Jul 2017 10:16:04 +0800

简介

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等

环境配置教程：

1、下载 JDK1.8:：点击下载

2、安装JDK

直接运行exe可执行程序，默认安装即可；
备注：路径可以选其他盘符，不建议路径包含中文名及特殊符号。

3、配置环境变量

win10下打开环境变量：此电脑（右击属性）-高级系统设置-环境变量

1新建变量名：JAVA_HOME，变量值：C:\Program Files\Java\jdk1.8.0_131

2 打开PATH，添加变量值：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin
3新建变量名：CLASSPATH，变量值：.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar

备注：
1.表示当前路径，%JAVA_HOME%就是引用前面指定的JAVA_HOME；
2 JAVA_HOME指明JDK安装路径，此路径下包括lib，bin，jre等文件夹，tomcat，eclipse等的运行都需要依靠此变量。
3 PATH使得系统可以在任何路径下识别java命令。
4 CLASSPATH为java加载类(class or lib)路径，只有类在classpath中，java命令才能识别。

4、测试jdk

在CMD命令窗口下输入javac java javadoc命令，出现如下界面，则安装成功。

5,安装eclipse：点击下载

下载完成解压点击 eclipse.exe 文件即可运行

清除QQ资料教程

Mon, 24 Jul 2017 17:36:30 +0800

今天看到名片不够简洁强迫症作祟，上网查了下教程没有一个能行，然后又想到很久很久以前老年机可以改性别啥的，回到家找到了老年机却坏了，最后我想到用java模拟器能模拟老版机，废话不多说让我们进入正题

需要材料:联网电脑一台(安卓4.4-5.0的可以去网上下载安卓版java模拟器用我这个qq.jar也是能使用的)

1.下载所需文件mnq.zip到电脑桌面
2.解压mnq.zip 里面有个java.zip(java模拟器)和qq.jar。
3.打开java.zip解压出的文件夹，找到KEmulator.exe
4.打开KEmulator.exe
5.点软件菜单栏的那个文件-载入jar
6.在搜索栏输入桌面，然后下拉找到解压出来的qq.jar并打开
7.童年回忆出现了，[这里全程用模拟键盘操作哦]第一次进来要设置qq号和密码，点软件菜单栏视图-模拟键盘
8.输入好qq密码即可登录
9.菜单-我的资料-个人资料
10.往下翻，找到年龄，出生日期那些东西，全部选-即可，点击修改，提示修改成功

11.打开qq查看资料，可以看到资料啥都没了，是不是很棒棒啊

分割线

----------------------------------------------------------------------------————————————————————————————————————————————————————————————————————————————————————————————

下载资料：点击下载

Java on 庞玉栋个人博客

Java两种方法实现简单爬虫

Hadoop 当中 Datanode节点不启动的解决办法

Java实现冒泡排序

人生苦短,我用python “Life is short. You need Python.”

大数据行业就业指南

如何从命令提示符运行Java程序

未来Kotlin取代Java或成为可能

Kotlin 扩展函数详解与应用

一、什么是扩展函数？

二、扩展函数的使用

（1）函数的扩展

● 在 Toast 中的高级用法

我们JAVA开发学习的七大作为

五分钟学会 Kotlin 语法

为什么使用Kotlin

修改说明

Kotlin 基本语法

java mail实现Email的发送,完整代码

深入理解Java虚拟机到底是什么

学习Java编程最有效的方法

1、培养兴趣

2、要脚踏实地

3、多实践，快实践

Java精选笔试题

1，volatile关键字是否能保证线程安全？（）

2，下面哪个流类属于面向字符的输入流( )

程序员如何高效学习（以 Java 为例）

Java小技巧，从运行、控制到框架

JAVA的图案为什么是咖啡

Java小技巧，从运行、控制到框架

Java项目实战经验—程序员成长的钥匙

java多线程高级教程，这些你都懂了吗？

Java入门学习进阶知识点汇总

Java在各个操作系统中的安装方式

GitHub 上最火的 Java 框架

深入解析Java垃圾回收机制

分享优秀Java程序员应有的编程风格

Java字符串的10大热点问题盘点

1、如何比较字符串，应该用”==”还是equals()？

2、对那些安全敏感的信息，为什么用char[]存储要优于String？

3、能否用字符串来声明switch语句？

4、如何将字符串转换成数字int类型？

5、如何用空格字符来分割字符串？

6、substring()方法究竟是什么？

7、String、StringBuilder和StringBuffer哪个更优？

8、如何重复输出字符串？

9、如何将字符串转换成日期类型？

10、如何统计指定字符在字符串中出现的频率

服务端 I/O 性能大比拼：Node、PHP、Java 和 Go

I/O基础知识：快速回顾

系统调用

阻塞调用与非阻塞调用

调度

多线程的方式：Java

Kotlin 将超越 Java 成为 Android 开发的第一语言？

JVM 语言的兴衰史

死磕 Java 并发 ：Java 内存模型之 happens-before

Java知识点归纳-J2EE 、 Web 部分

Java总结篇系列：Java泛型

Java面试常被问到的题目+解答

Java 中的异常和处理详解

Java序列化的几种方式以及序列化的作用

一.Java序列化的作用

二.实现java对象的序列化和反序列化。

Java 和 JavaScript 的关系！

为什么Java程序员薪资一直居高不下？

开发人员需要掌握的英文词汇，必须要学会的

java邮件类---MailUtils 用户网站统一发送激活码

学习Java需吃透这些基本概念你知道吗？

书城注册登录servlet--UserService.java

Java验证码的绘制

Java-Filter过滤器用于过滤整个项目的编码

Java项目实战经验—程序员成长的钥匙

程序猿幽默你是学不来的！

java和JavaScript究竟是什么关系？

真正的Java学习从入门到精通，只需拿下这6点！

1、 JDK的下载和安装

2、 JDK的命令工具

【分享】Java并发面试题精选

死磕 Java 并发：Java 内存模型之 happens-before

构建联合查询语句用于查询三联表中的数据

在有main函数的前提下 eclipse找不到主类解决办法

Node11Panel类添加人员信息操作

”无法解析类型这是简介引用的类文件要求从必需的 .class 文件间接引用了“——解决方法