public class Test {

 /**
  * @param args
  * @throws java.text.ParseException
  */

 public static void main(String[] args) throws java.text.ParseException {
  // Date dateNow = new Date();
  //
  // String dateNowStr = dateFormat.format(dateNow);
  // System.out.println(dateNowStr);

  final String dayNames[] = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五",
    "星期六" };
  SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日");

  Calendar calendar = Calendar.getInstance();
  Date date = new Date();
  String datarq = dateFormat.format(date); //日期
  
  calendar.setTime(date);
  int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
  if (dayOfWeek < 0)
   dayOfWeek = 0;

  System.out.println(datarq + "  " + dayNames[dayOfWeek]);

 }

}

开始–运行–cmd 进入命令提示符 输入netstat -ano 即可看到所有连接的PID 之后在任务管理器中找到这个PID所对应的程序如果任务管理器中没有PID这一项,可以在任务管理器中选”查看”-”选择列”

经常，我们在启动应用的时候发现系统需要的端口被别的程序占用，如何知道谁占有了我们需要的端口，很多人都比较头疼，下面就介绍一种非常简单的方法，希望对大家有用。

我们需要确定谁占用了我们的80端口

在windows命令行窗口下执行：
C:\>netstat -aon|findstr “80″
 TCP    0.0.0.0:19780             0.0.0.0:0                    LISTENING         2044
 TCP    10.72.224.5:2558       96.17.109.8:80          ESTABLISHED     2044
 TCP    10.72.224.5:2757       60.210.176.209:80    TIME_WAIT         0
 TCP    10.72.224.5:3956       125.46.1.234:80        ESTABLISHED     2044
 TCP    10.72.224.5:3959       125.46.1.234:80        ESTABLISHED     2044
 UDP    0.0.0.0:2280               *:*                                                       3700

看到了吗，端口被进程号为2044的进程占用，继续执行下面命令：
C:\>tasklist|findstr “2044″
avp.exe                     2044 Console                 0     37,680 K
很清楚吧，avp 卡巴监听80端口，调整卡巴网络监听设置。
当然，如果你的80端口被其他程序占用，kill掉或者调整端口。

package l6;
/**
 * 实现栈的数据结构
 */
import java.util.LinkedList;

public class MyStack {
 LinkedList mylist = new LinkedList();

 public void push(Object o) {
  mylist.addFirst(o);
 }

 public Object pop() {
  return mylist.removeFirst();
 }

 public Object peek() {
  return mylist.getFirst();
 }

 public boolean empty() {
  return mylist.isEmpty();
 }
 
 
 public static void main(String[] args) {
  MyStack  ms = new MyStack();
  ms.push("1");
  ms.push("2");
  ms.push("3");
  ms.push("4");
  
  System.out.println(ms.pop());
  System.out.println(ms.pop());
  System.out.println(ms.peek());
  System.out.println(ms.empty());
 }
}

package l6;

import java.util.LinkedList;

/**
 * 实现队列的数据结构
 *
 */
public class MyQueue {

 private LinkedList ll = new LinkedList();

 public void put(Object o) {
  ll.addLast(o);
 }

 public Object get() {
  return ll.removeFirst();
 }

 public Object peek() {
  return ll.getFirst();
 }

 public boolean empty() {
  return ll.isEmpty();
 }

 /**
  * @param args
  */
 public static void main(String[] args) {

  MyQueue mq = new MyQueue();
  mq.put("1");
  mq.put("2");
  mq.put("3");
  mq.put("4");
  mq.put("5");
  mq.put("6");

  System.out.println(mq.get());
  System.out.println(mq.get());
  System.out.println(mq.get());
  System.out.println(mq.get());
  System.out.println(mq.peek());
  System.out.println(mq.empty());
 }

}

//学生类
package l6;

import java.util.Comparator;

public class Student implements Comparable {

 public int num;
 public String name;
 

 public Student(int num, String name) {
  this.num = num;
  this.name = name;
 }

 public int compareTo(Object o) {
  Student s = (Student) o;
  if (num > s.num) {
   return 1;
  } else if (num == s.num) {
   return 0;
  } else {
   return -1;
  }
 }

 public String toString() {
  return "num:" + num + " name:" + name;
 }

 public int compare(Object o1, Object o2) {
  // TODO Auto-generated method stub
  return 0;
 }
}

//学生比较器

package l6;

import java.util.Comparator;

public  class StudentComparator implements Comparator {

 public int compare(Object o1, Object o2) {
  Student s1 = (Student) o1;
  Student s2 = (Student) o2;
  if (s1.num > s2.num) {
   return 1;
  } else if (s1.num < s2.num) {
   return -1;
  } else {
   return s1.name.compareTo(s2.name);
  }
 }
}

//测试类
package l6;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;

public class ArrayListTest {

 /**
  * @param args
  */

 public static void main(String[] args) {

  ArrayList<Student> slist = new ArrayList<Student>();
  Student s1 = new Student(1, "z1");
  slist.add(s1);
  Student s3 = new Student(2, "z3");
  slist.add(s3);
  Student s2 = new Student(2, "z2");
  slist.add(s2);
  Student s5 = new Student(2, "z5");
  slist.add(s5);
  Student s4 = new Student(4, "z4");
  slist.add(s4);

   // Collections.sort(slist); //未使用比较器
    Collections.sort(slist, new StudentComparator());//未使用比较器
  PaintE(slist);

 }

 public static void PaintE(Collection c) {
  Iterator it = c.iterator();
  while(it.hasNext()){
   System.out.println(it.next().toString());
  }
  

 }

}

 

 

//All the divs on the page:
$$('div');

//All the divs and paragraphs
//note: this returns an array with all the divs first,then all the paragraphs:
$$('div', 'p');

//All the divs with the css class 'myClass':
$$('div.myClass')

/All the paragraphs that are inside divs:
$$('div p');

//All the bold tags in paragraphs with Class 'foo' in divs with class 'myClass':
$$('div.myClass p.foo b');

<1>hasClass 应用
Examples:
HTML
<div id="myElement" class="testClass"></div>
JavaScript
$('myElement').hasClass('testClass'); // returns true

<2>addClass 应用

Examples:
HTML
<div id="myElement" class="testClass"></div>
JavaScript
$('myElement').addClass('newClass');

<3>removeClass 应用
Examples:
HTML
<div id="myElement" class="testClass newClass"></div>
JavaScript
$('myElement').removeClass('newClass');
Resulting HTML
<div id="myElement" class="testClass"></div>

<4>toggleClass 应用
Adds or removes the passed in class name to the Element, depending on whether or not it's already present.
Examples:
HTML
<div id="myElement" class="myClass"></div>
JavaScript
$('myElement').toggleClass('myClass');
Resulting HTML
<div id="myElement" class=""></div>

JavaScript
$('myElement').toggleClass('myClass');
Resulting HTML
<div id="myElement" class="myClass"></div>

 

        打印集合类的对象，将调用所有元素的toString()方法，如果是自己写的类，则要实现toString()方法；  

Java关键字final、static使用总结

Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。

final类不能被继承，没有子类，final类中的方法默认是final的。

final方法不能被子类的方法覆盖，但可以被继承。

final成员变量表示常量，只能被赋值一次，赋值后值不再改变。

final不能用于修饰构造方法。

注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。

1、final类

　final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。

2、final方法

如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。

使用final方法的原因有二：

第一、把方法锁定，防止任何继承类修改它的意义和实现。

第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。

3、final变量（常量）

　用final修饰的成员变量表示常量，值一旦给定就无法改变！

　final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。

4、final参数

当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。

二、static

　static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。

　被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

　用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。

　static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。

　static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：

类名.静态方法名(参数列表...)

类名.静态变量名

　用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处非常大，呵呵）。

1、static变量

　按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是：

　对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。

　对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。

2、静态方法

　静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！

　因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

3、static代码块

　static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

　利用静态代码块可以对一些static变量进行赋值，最后再看一眼这些例子，都一个static的main方法，这样JVM在运行main方法的时候可以直接调用而不用创建实例。

4、static和final一块用表示什么

static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！

对于变量，表示一旦给值就不可修改，并且通过类名可以访问。

对于方法，表示不可覆盖，并且可以通过类名直接访问。

  

为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。
在派生类中覆盖基类的clone()方法，并声明为public。
在派生类的clone()方法中，调用super.clone()。
在派生类中实现Cloneable接口。

为什么我们在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。

  Student s1 = new Student("gaoer", 14);
  System.out.println("s1name=" + s1.getName());
  
  Student s2 = s1; // 未使用clone，他俩使用一个地址，
  s2.setAge(12);
  s2.setName("zhangsan");
  System.out.println("s1name=" + s1.getName());

  Student s3 = (Student) s1.clone();
  s3.setAge(12);
  s3.setName("lisi");
  System.out.println("s1name=" + s1.getName());

package l4;
/**
 *
 * @author Administrator
 * 当没有引用类型的变量时，为浅层次的拷贝
 *
 */
public class Student implements Cloneable {
 private String name;
 private int age;

 public Student(String name, int age) {

  this.name = name;
  this.age = age;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  this.age = age;
 }

 protected Object clone() throws CloneNotSupportedException {

  Object o = null;
  o = super.clone();
  return o;
 }

}

package l4;
/**
 *
 * @author Administrator
 * 当没有引用类型的变量时，为浅层次的克隆
 * 当有引用类型的变量时，为深层次的克隆
 */
public class Student implements Cloneable {
 private String name;
 private int age;
 Point pt;

 public Student(String name, int age) {

  this.name = name;
  this.age = age;
 }
 public Student(String name, int age,Point pt) {

  this.name = name;
  this.age = age;
  this.pt = pt;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  this.age = age;
 }

 protected Object clone() throws CloneNotSupportedException {

  Student o = null;
  o = (Student)super.clone();
  o.pt = (Point)pt.clone();
  return o;
 }

}

package l4;

public class Point implements Cloneable {
 public int x;
 public int y;

 @Override
 public String toString() {
  return "x=" + x + "y=" + y;
 }

 protected Object clone() throws CloneNotSupportedException {
  Object o = null;
  o = super.clone();
  return o;
 }
}

java 函数参数传递都是传值
对于基本数据类型，传递的是数据的拷贝；
对于引用类型，传递的是引用的拷贝； 

  int x = 3;
  int y = 4;
  change(x, y);
  System.out.println("x=" + x + "y=" + y);
  //不可交换

  int[] num1 = new int[]{3,4};
  change(num1);
  System.out.println("num x=" + num1[0] + "num y=" + num1[1]);
  //可交换

  Point pt = new Point();
  pt.x = 3;
  pt.y = 4;
  change(pt);
  System.out.println("pt.x=" + pt.x + "pt.y=" + pt.y);
//可交换

public static void change(int x, int y) {
  x = x + y;
  y = x - y;
  x = x - y;
 }

 public static void change(int[] num) {
  num[0] = num[0] + num[1];
  num[1] = num[0] - num[1];
  num[0] = num[0] - num[1];
 }

 public static void change(Point pt) {
  pt.x = pt.x + pt.y;
  pt.y = pt.x - pt.y;
  pt.x = pt.x - pt.y;
 }

Eclipse快捷键大全
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 定位到对于的匹配符(譬如{}) (从前面定位后面时,光标要在匹配符里面,后面到前面,则反之)

下面的快捷键是重构里面常用的,本人就自己喜欢且常用的整理一下(注:一般重构的快捷键都是Alt+Shift开头的了)
Alt+Shift+R 重命名 (是我自己最爱用的一个了,尤其是变量和类的Rename,比手工方法能节省很多劳动力)
Alt+Shift+M 抽取方法 (这是重构里面最常用的方法之一了,尤其是对一大堆泥团代码有用)
Alt+Shift+C 修改函数结构(比较实用,有N个函数调用了这个方法,修改一次搞定)
Alt+Shift+L 抽取本地变量( 可以直接把一些魔法数字和字符串抽取成一个变量,尤其是多处调用的时候)
Alt+Shift+F 把Class中的local变量变为field变量 (比较实用的功能)
Alt+Shift+I 合并变量(可能这样说有点不妥Inline)
Alt+Shift+V 移动函数和变量(不怎么常用)
Alt+Shift+Z 重构的后悔药(Undo)

编辑
作用域 功能 快捷键
全局 查找并替换 Ctrl+F
文本编辑器 查找上一个 Ctrl+Shift+K
文本编辑器 查找下一个 Ctrl+K
全局 撤销 Ctrl+Z
全局 复制 Ctrl+C
全局 恢复上一个选择 Alt+Shift+↓
全局 剪切 Ctrl+X
全局 快速修正 Ctrl1+1
全局 内容辅助 Alt+/
全局 全部选中 Ctrl+A
全局 删除 Delete
全局 上下文信息 Alt+？
Alt+Shift+?
Ctrl+Shift+Space
Java编辑器 显示工具提示描述 F2
Java编辑器 选择封装元素 Alt+Shift+↑
Java编辑器 选择上一个元素 Alt+Shift+←
Java编辑器 选择下一个元素 Alt+Shift+→
文本编辑器 增量查找 Ctrl+J
文本编辑器 增量逆向查找 Ctrl+Shift+J
全局 粘贴 Ctrl+V
全局 重做 Ctrl+Y

 
查看
作用域 功能 快捷键
全局 放大 Ctrl+=
全局 缩小 Ctrl+-

 
窗口
作用域 功能 快捷键
全局 激活编辑器 F12
全局 切换编辑器 Ctrl+Shift+W
全局 上一个编辑器 Ctrl+Shift+F6
全局 上一个视图 Ctrl+Shift+F7
全局 上一个透视图 Ctrl+Shift+F8
全局 下一个编辑器 Ctrl+F6
全局 下一个视图 Ctrl+F7
全局 下一个透视图 Ctrl+F8
文本编辑器 显示标尺上下文菜单 Ctrl+W
全局 显示视图菜单 Ctrl+F10
全局 显示系统菜单 Alt+-

 
导航
作用域 功能 快捷键
Java编辑器 打开结构 Ctrl+F3
全局 打开类型 Ctrl+Shift+T
全局 打开类型层次结构 F4
全局 打开声明 F3
全局 打开外部javadoc Shift+F2
全局 打开资源 Ctrl+Shift+R
全局 后退历史记录 Alt+←
全局 前进历史记录 Alt+→
全局 上一个 Ctrl+,
全局 下一个 Ctrl+.
Java编辑器 显示大纲 Ctrl+O
全局 在层次结构中打开类型 Ctrl+Shift+H
全局 转至匹配的括号 Ctrl+Shift+P
全局 转至上一个编辑位置 Ctrl+Q
Java编辑器 转至上一个成员 Ctrl+Shift+↑
Java编辑器 转至下一个成员 Ctrl+Shift+↓
文本编辑器 转至行 Ctrl+L

 
搜索
作用域 功能 快捷键
全局 出现在文件中 Ctrl+Shift+U
全局 打开搜索对话框 Ctrl+H
全局 工作区中的声明 Ctrl+G
全局 工作区中的引用 Ctrl+Shift+G

 
文本编辑
作用域 功能 快捷键
文本编辑器 改写切换 Insert
文本编辑器 上滚行 Ctrl+↑
文本编辑器 下滚行 Ctrl+↓

 
文件
作用域 功能 快捷键
全局 保存 Ctrl+X
Ctrl+S
全局 打印 Ctrl+P
全局 关闭 Ctrl+F4
全局 全部保存 Ctrl+Shift+S
全局 全部关闭 Ctrl+Shift+F4
全局 属性 Alt+Enter
全局 新建 Ctrl+N

 
项目
作用域 功能 快捷键
全局 全部构建 Ctrl+B

 
源代码
作用域 功能 快捷键
Java编辑器 格式化 Ctrl+Shift+F
Java编辑器 取消注释 Ctrl+\
Java编辑器 注释 Ctrl+/
Java编辑器 添加导入 Ctrl+Shift+M
Java编辑器 组织导入 Ctrl+Shift+O
Java编辑器 使用try/catch块来包围 未设置，太常用了，所以在这里列出,建议自己设置。
也可以使用Ctrl+1自动修正。

 
运行
作用域 功能 快捷键
全局 单步返回 F7
全局 单步跳过 F6
全局 单步跳入 F5
全局 单步跳入选择 Ctrl+F5
全局 调试上次启动 F11
全局 继续 F8
全局 使用过滤器单步执行 Shift+F5
全局 添加/去除断点 Ctrl+Shift+B
全局 显示 Ctrl+D
全局 运行上次启动 Ctrl+F11
全局 运行至行 Ctrl+R
全局 执行 Ctrl+U

 
重构
作用域 功能 快捷键
全局 撤销重构 Alt+Shift+Z
全局 抽取方法 Alt+Shift+M
全局 抽取局部变量 Alt+Shift+L
全局 内联 Alt+Shift+I
全局 移动 Alt+Shift+V
全局 重命名 Alt+Shift+R
全局 重做 Alt+Shift+Y

<数据类型>[] 变量名 = new <数据类型>[数组长度]
int[] a = new int[5]
int a[1]=1;
int a[2]=2;
int a[3]=3;
int a[4]=4;
int a[5]=5;

int[] a = {1,2,3,4,5,6}

 

抽象类：

用absstract定义的类为抽象类，抽象类可以包含抽象方法也可以包含具体的方法；

没有方法体的方法为抽象方法；

抽象的类不能创建对象，只能通过继承使用这个类；

只用覆盖了父类中的方法后，才能实例化，才能使用；

模板方法，用来定义规则；

接口：

接口就是特殊的类；

接口内没有具体的方法，只能包含抽象的方法；

接口内默认就是抽象方法，不用加abstract;

接口内的方法默认是公用的，不用加public；

接口不能实例化；

接口可以被继承，产生子接口，子接口也不能创建对象；

通过implements实现接口；

接口可以出现变量，但都是常量，用final定义，在声明的时候就赋值，默认是final、static；

final最终的，不允许修改；

父类能适用的地方，子类也能适用；

Linux下可以超过3G，Windows下最大也就1.6G左右（x86）。

一般32位的机器做大只能用到2G内存，4G内存可以跑2个tomcat,通过Apache做cluster.