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這一項,可以在任務管理器中選”查看”-”選擇列”

經(jīng)常，我們在啟動應用的時候發(fā)現(xiàn)系統(tǒng)需要的端口被別的程序占用，如何知道誰占有了我們需要的端口，很多人都比較頭疼，下面就介紹一種非常簡單的方法，希望對大家有用。

我們需要確定誰占用了我們的80端口

在windows命令行窗口下執(zhí)行：
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的進程占用，繼續(xù)執(zhí)行下面命令：
C:\>tasklist|findstr “2044″
avp.exe                     2044 Console                 0     37,680 K
很清楚吧，avp 卡巴監(jiān)聽80端口，調(diào)整卡巴網(wǎng)絡監(jiān)聽設置。
當然，如果你的80端口被其他程序占用，kill掉或者調(diào)整端口。

package l6;
/**
 * 實現(xiàn)棧的數(shù)據(jù)結構
 */
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;

/**
 * 實現(xiàn)隊列的數(shù)據(jù)結構
 *
 */
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>

 

        打印集合類的對象，將調(diào)用所有元素的toString()方法，如果是自己寫的類，則要實現(xiàn)toString()方法；  

Java關鍵字final、static使用總結

Java關鍵字final有“這是無法改變的”或者“終態(tài)的”含義，它可以修飾非抽象類、非抽象類成員方法和變量。你可能出于兩種理解而需要阻止改變：設計或效率。

final類不能被繼承，沒有子類，final類中的方法默認是final的。

final方法不能被子類的方法覆蓋，但可以被繼承。

final成員變量表示常量，只能被賦值一次，賦值后值不再改變。

final不能用于修飾構造方法。

注意：父類的private成員方法是不能被子類方法覆蓋的，因此private類型的方法默認是final類型的。

1、final類

　final類不能被繼承，因此final類的成員方法沒有機會被覆蓋，默認都是final的。在設計類時候，如果這個類不需要有子類，類的實現(xiàn)細節(jié)不允許改變，并且確信這個類不會載被擴展，那么就設計為final類。

2、final方法

如果一個類不允許其子類覆蓋某個方法，則可以把這個方法聲明為final方法。

使用final方法的原因有二：

第一、把方法鎖定，防止任何繼承類修改它的意義和實現(xiàn)。

第二、高效。編譯器在遇到調(diào)用final方法時候會轉(zhuǎn)入內(nèi)嵌機制，大大提高執(zhí)行效率。

3、final變量（常量）

　用final修飾的成員變量表示常量，值一旦給定就無法改變！

　final修飾的變量有三種：靜態(tài)變量、實例變量和局部變量，分別表示三種類型的常量。

4、final參數(shù)

當函數(shù)參數(shù)為final類型時，你可以讀取使用該參數(shù)，但是無法改變該參數(shù)的值。

二、static

　static表示“全局”或者“靜態(tài)”的意思，用來修飾成員變量和成員方法，也可以形成靜態(tài)static代碼塊，但是Java語言中沒有全局變量的概念。

　被static修飾的成員變量和成員方法獨立于該類的任何對象。也就是說，它不依賴類特定的實例，被類的所有實例共享。只要這個類被加載，Java虛擬機就能根據(jù)類名在運行時數(shù)據(jù)區(qū)的方法區(qū)內(nèi)定找到他們。因此，static對象可以在它的任何對象創(chuàng)建之前訪問，無需引用任何對象。

　用public修飾的static成員變量和成員方法本質(zhì)是全局變量和全局方法，當聲明它類的對象市，不生成static變量的副本，而是類的所有實例共享同一個static變量。

　static變量前可以有private修飾，表示這個變量可以在類的靜態(tài)代碼塊中，或者類的其他靜態(tài)成員方法中使用（當然也可以在非靜態(tài)成員方法中使用--廢話），但是不能在其他類中通過類名來直接引用，這一點很重要。實際上你需要搞明白，private是訪問權限限定，static表示不要實例化就可以使用，這樣就容易理解多了。static前面加上其它訪問權限關鍵字的效果也以此類推。

　static修飾的成員變量和成員方法習慣上稱為靜態(tài)變量和靜態(tài)方法，可以直接通過類名來訪問，訪問語法為：

類名.靜態(tài)方法名(參數(shù)列表...)

類名.靜態(tài)變量名

　用static修飾的代碼塊表示靜態(tài)代碼塊，當Java虛擬機（JVM）加載類時，就會執(zhí)行該代碼塊（用處非常大，呵呵）。

1、static變量

　按照是否靜態(tài)的對類成員變量進行分類可分兩種：一種是被static修飾的變量，叫靜態(tài)變量或類變量；另一種是沒有被static修飾的變量，叫實例變量。兩者的區(qū)別是：

　對于靜態(tài)變量在內(nèi)存中只有一個拷貝（節(jié)省內(nèi)存），JVM只為靜態(tài)分配一次內(nèi)存，在加載類的過程中完成靜態(tài)變量的內(nèi)存分配，可用類名直接訪問（方便），當然也可以通過對象來訪問（但是這是不推薦的）。

　對于實例變量，沒創(chuàng)建一個實例，就會為實例變量分配一次內(nèi)存，實例變量可以在內(nèi)存中有多個拷貝，互不影響（靈活）。

2、靜態(tài)方法

　靜態(tài)方法可以直接通過類名調(diào)用，任何的實例也都可以調(diào)用，因此靜態(tài)方法中不能用this和super關鍵字，不能直接訪問所屬類的實例變量和實例方法(就是不帶static的成員變量和成員成員方法)，只能訪問所屬類的靜態(tài)成員變量和成員方法。因為實例成員與特定的對象關聯(lián)！這個需要去理解，想明白其中的道理，不是記憶！??！

　因為static方法獨立于任何實例，因此static方法必須被實現(xiàn)，而不能是抽象的abstract。

3、static代碼塊

　static代碼塊也叫靜態(tài)代碼塊，是在類中獨立于類成員的static語句塊，可以有多個，位置可以隨便放，它不在任何的方法體內(nèi)，JVM加載類時會執(zhí)行這些靜態(tài)的代碼塊，如果static代碼塊有多個，JVM將按照它們在類中出現(xiàn)的先后順序依次執(zhí)行它們，每個代碼塊只會被執(zhí)行一次。

　利用靜態(tài)代碼塊可以對一些static變量進行賦值，最后再看一眼這些例子，都一個static的main方法，這樣JVM在運行main方法的時候可以直接調(diào)用而不用創(chuàng)建實例。

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

static final用來修飾成員變量和成員方法，可簡單理解為“全局常量”！

對于變量，表示一旦給值就不可修改，并且通過類名可以訪問。

對于方法，表示不可覆蓋，并且可以通過類名直接訪問。

  

為了獲取對象的一份拷貝，我們可以利用Object類的clone()方法。
在派生類中覆蓋基類的clone()方法，并聲明為public。
在派生類的clone()方法中，調(diào)用super.clone()。
在派生類中實現(xiàn)Cloneable接口。

為什么我們在派生類中覆蓋Object的clone()方法時，一定要調(diào)用super.clone()呢？在運行時刻，Object中的clone()識別出你要復制的是哪一個對象，然后為此對象分配空間，并進行對象的復制，將原始對象的內(nèi)容一一復制到新對象的存儲空間中。

  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 函數(shù)參數(shù)傳遞都是傳值
對于基本數(shù)據(jù)類型，傳遞的是數(shù)據(jù)的拷貝；
對于引用類型，傳遞的是引用的拷貝； 

  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;
 }