sunnyandgood / myblog Goto Github PK

public class Test {
	public static void permutation(char[] strE, int begin) {
		if(begin == strE.length){
			System.out.println(new String(strE));
		}else{
			for(int i=begin;i<strE.length;i++){
				if(isSwap(strE,begin,i)){
					char temp = strE[i];
					strE[i] = strE[begin];
					strE[begin] = temp;
					
					permutation(strE,begin+1);
					
					temp = strE[i];
					strE[i] = strE[begin];
					strE[begin] = temp;
				}
			}
		}
	}

	public static boolean isSwap(char[] strE, int begin, int end) {
		for(int i=begin;i<end;i++) {
			if(strE[i]==strE[end]) {
				return false;
			}
		}
		return true;
	}
}

1、创建form表单，确定提交方式
2、创建servlet类：创建类，继承HttpServlet，该类在servlet-api.jar
 复写doGet/doPost方法
3、配置请求映射
  <servlet>
   <!--servlet名称，与配置文件中的<servlet-mapping>标签中的servlet-name匹配-->
   <servlet-name>servlet01</servlet-name>
   <!--servlet类的全名称，原理：Java反射机制-->
   <servlet-class>com.wxkj.servlet.action.ServletAction</servlet-class>
  </servlet>
  <servlet-mapping>
    <!--servlet名称，与配置文件中的<servlet>标签中的servlet-name匹配-->
   <servlet-name>servlet01</servlet-name>
   <!--响应请求，当浏览器请求到达时，此处首先匹配-->
   <url-pattern>/form01</url-pattern>
  </servlet-mapping>
4、表单的method属性决定了servlet类对象呗访问的是doGet还是doPost
 method属性值为get，则访问doGet
 method属性值为post，则访问doPost
 超链接相当于显示提交，访问doGet
 浏览器地址栏直接敲请求，也为get方式
5、servlet生命周期 
 init()初始化方法，当servlet被创建时调用，一般做初始化处理
 service(HttpServletRequest arg0, HttpServletResponse arg1)
  整个生命周期过程中调用的方法，所有的请求都走service方法
  如果service方法中调用父类service方法，则根据提交方式自动分发给doGet/doPost方法
 destroy()销毁，当servlet被销毁时调用，一般做警告处理
6、<load-on-startup>0</load-on-startup>
 当服务器启动时创建servlet实例
 标签包裹的部分为整数类型数字
 当数字大于等于0时，数字越小，创建越早
 当数字小于0时，等同于不写该标签 
7、自定义方法的使用
 创建自定义方法，在service方法中进行调用
 在请求中添加状态参数，service根据状态参数来决定调用哪一个自定义方法

源码：
public StringTokenizer(String str) {
	this(str, ” \t\n\r\f”, false);
}

import java.util.StringTokenizer;

public class Test {

	public static void main(String[] args) {  
		StringTokenizer stringTokenizer = new StringTokenizer("www hao123 com");  
		 while(stringTokenizer.hasMoreElements()){  
			 System.out.println("print:" + stringTokenizer.nextToken());  
		 }  
	} 
}
输出：
print:www
print:hao123
print:com

import java.util.StringTokenizer;

public class Test  {

	public static void main(String[] args) {  
		StringTokenizer stringTokenizer = new StringTokenizer("www.hao123.com", ".1");  
		 while(stringTokenizer.hasMoreElements()){  
			 System.out.println("print:" + stringTokenizer.nextToken());  
		 }  
	}  
}

输出：
print:www
print:hao
print:23
print:com

import java.util.StringTokenizer;

public class Test {

	public static void main(String[] args) {  
		  StringTokenizer stringTokenizer = new StringTokenizer("www.hao123.com", ".", true);  
		  while(stringTokenizer.hasMoreElements()){  
		  System.out.println("print:" + stringTokenizer.nextToken());  
		  }  
	} 
	
}
输出：
print:www
print:.
print:hao123
print:.
print:com

public class Test {

	public static void main(String[] args) {  
		  String a = "www.hao123.com";
		  System.out.println(a);
		  String b = a.substring(2);
		  System.out.println(b);
		  String c = a.substring(1,10);
		  System.out.println(c);
		  String d = a.substring(6, a.length()); 
		  System.out.println(d);
	}  
}

输出：
www.hao123.com
w.hao123.com
ww.hao123
o123.com

注：beginIndex不能为负数，endIndex不能超出字符串长度，否则会抛出StringIndexOutOfBoundsException异常

var str="abcdefgh";
document.write(str.substring(0,1));//return:a
document.write(str.substring(2,5));//return:cde
document.write(str.substring(7,8));//return:h

#include<iostream>
#include<string.h>
#include<stdlib.h>
#include <sstream>
using namespace std;

long long countNum = 0;
bool IsSwap(char* pBegin, char* pEnd)
{
    char* p;
    for (p=pBegin; p<pEnd; p++)
    {
        if (*p == *pEnd)
            return false;
    }
    return true;
}

void Permutation(char* pStr, char* pBegin,char *pre_str,int m)
{
    if (*pBegin == '\0')
    {
        if (strcmp(pre_str, pStr) > 0)//如果pre_str>pStr则返回正数
        {
            stringstream ss;
            long long ll;
            ss<<pStr;
            ss>>ll;
            if(ll%m == 0)
            {
                countNum++;
            }
            //countNum++;
            /*if (strtol(pStr, NULL, 10)%m == 0)//将pStr转换为10进制数
            {
                countNum++;
            }*/
        }
    }
    else
    {
        for (char* pCh = pBegin; *pCh!='\0'; pCh++)
        {
            if( IsSwap(pBegin,pCh) )
            {
                char temp = *pCh;
                *pCh = *pBegin;
                *pBegin = temp;

                Permutation(pStr, pBegin+1,pre_str,m);

                temp = *pCh;
                *pCh = *pBegin;
                *pBegin = temp;
            }
        }
    }
}

int main()
{
    long long out[50];
    char strE[100];
    int time,m;
    char pre_str[100] = {0};
    cout<<"The time is: ";
    cin>>time;
    cout<<endl;

    cout<<"The original strings is: "<<endl;
    for (int i = 0; i < time; i++)
    {
        cin>>strE>>m;
        strcpy(pre_str, strE);
        Permutation(strE,strE,pre_str,m);
        out[i] = countNum%1000000007;
        countNum = 0;
    }

    cout<<"After permutation select, the price possible number  is: "<<endl;
    for (int i = 0; i < time; i++)
    {
        cout<<out[i]<<endl;
    }
    return 0;
}

import java.math.BigInteger;
import java.util.Scanner;
public class Zimbabwe {
	private static double count = 0; 
	
	public static void main(String[] args) {
		Zimbabwe zimbabwe = new Zimbabwe();
		double value[] = new double[50];
		char strE[] = new char[100]; 
		int time;
		int m;
		
		System.out.print("The time is: ");
		
		Scanner input = new Scanner(System.in);
		time = input.nextInt();
		System.out.println();
		
		
		for(int i=0;i<time;i++){
			char pre_str[] = new char[100];
			String str = input.next();
			m = input.nextInt();
			
			strE = str.toCharArray();
			pre_str = zimbabwe.copyOf(strE);
			zimbabwe.permutation(strE,0,pre_str,m);
			value[i] = count%1000000007;
			count = 0;
		}
		
		System.out.println("The original strings is: ");
		
		for(int i=0;i<time;i++){
			String str = String.valueOf(value[i]);
			String arr[] = str.split("\\.");
			System.out.println(arr[0]);
		}
	}

	private char[] copyOf(char[] strE) {
		int length = strE.length;
		char[] str = new char[length];
		for(int i=0;i<length;i++){
			str[i] = strE[i];
		}
		return str;
	}

	private void permutation(char[] strE, int begin, char[] pre_str, int m) {
		Zimbabwe zimbabwe = new Zimbabwe();
		if(begin == strE.length){
			if(zimbabwe.compare(pre_str,strE)){
				if(zimbabwe.doubleParseInt(strE, m)){//zimbabwe.bigIntegerParseInt(strE, m)
					count++;
				}
			}
		}else{
			for(int i=begin;i<strE.length;i++){
				if(zimbabwe.isSwap(strE,begin,i)){
					char temp = strE[i];
					strE[i] = strE[begin];
					strE[begin] = temp;
					
					zimbabwe.permutation(strE,begin+1,pre_str,m);
					
					temp = strE[i];
					strE[i] = strE[begin];
					strE[begin] = temp;
				}
			}
		}
	}

	private boolean doubleParseInt(char[] strE,int m) {
		String str = new String(strE);
		double num = Double.valueOf(str);
		if(num%m==0.0)
			return true;
		return false;
	}
	
	private boolean bigIntegerParseInt(char[] strE,int m){
		String str = new String(strE);
		BigInteger bigNum = new BigInteger(str);
		BigInteger bigM = BigInteger.valueOf(m);
		if(bigNum.remainder(bigM) != null)
			return true;
		return false;
	}

	private boolean numParseInt(char[] strE,int m) {
		double value = 0.0;
		for(int i=0;i<strE.length;i++) {
			value = value+strE[i]*Math.pow(10.0,strE.length-1-i);
		}
		if(value%m==0.0)
			return true;
		return false;
	}

	private boolean isSwap(char[] strE, int begin, int end) {
		for(int i=begin;i<end;i++) {
			if(strE[i]==strE[end]) {
				return false;
			}
		}
		return true;
	}

	private boolean compare(char[] str1, char[] str2) {
		String string1 = new String(str1);
		String string2 = new String(str2);
		if(string1.compareTo(string2) > 0){
			return true;
		}
		else {
			return false;
		}
	}
}

例如：int[] a=new int[]{123,445,567};
     int[] b=new int[]{123,556,677};

比较：  返回 -1，0，1
数组第一个数大，数组大
如果第一个相等，比较第二个，第二个大，数组大
如果第二个相等，比较第三个，第三个大，数组大。。。。。。

/**
  * @author wrh
  */
 public class Test {
     public static void main(String[] args) {
    	 int a[] = {123,445,567};
         int b[] = {123,556,677};
      
         int value = compare1(a,b,max(a.length,b.length));
         System.out.println(value);
     }
     //用while循环
     public static int compare1(int[] a, int[] b, int len) {
           int i = 0;
	   while(i<len)
	  {
		if(a[i]>b[i])
			return 1;
		if(a[i]<b[i])
			rturn -1;
		i++;
	  }
	  return 0;
    }
      //递归实现
     public static int compare2(int[] a, int[] b, int len)
     {
    	int length = max(a.length,b.length);
    	int first = length-len;
        if(a[first]>b[first])
        {
            return 1;
        }
        else if(a[first]<b[first])
        {
            return -1;
        }
        else if(len==1)
        {
            return 0;
        }
        else
        {
            return compare2(a,b,len-1);
        }
     }
      
    public static int max(int length1, int length2) {
	   return (length1>length2)?length1:length2;
    }
}

public class Test {

	public static void main(String[] args) {
		double number = 123456;
		String str = String.valueOf(number);  //转换为字符串  
	    int length = str.length();  
	    String strNumber[] = new String[length];  
	
	    for (int i = 0; i < length; i++) {  
	        strNumber[i] = str.substring(i, i + 1);
	    }
	    for (int i = 0; i < length; i++) {  
	        System.out.println(strNumber[i]);
	    }
	}  
}

public class Test {

	public static void main(String[] args) {
		String str1 = new String("12738173912");
		double num = Double.valueOf(str1);
		double value = num%7.0;
		String str2 = String.valueOf(value);
		String arr[] = str2.split("\\.");
		System.out.println(arr[0]);
	}  
}

char[] c1 = new char[]{'a','d','s'};
return = Arrays.toString(c1);

输出效果：[a, d, s]

char[] c4 = new char[]{'a','d','s','a','d','s'};
StringBuffer sb = new StringBuffer();
for(int i = 1;i<c4.length;i++){
     sb.append(c4);            
}
System.out.println(c4);

输出效果：adsads

char[] c4 = new char[]{'a','d','s','a','d','s'};
return new String(c4);

输出效果：adsads

import java.util.Scanner;

//父类
class ParentSort
{
	public void sort(int[] array)
	{
		System.out.println("排序算法");
	}
	public void showArray(int[] array)
	{
		for(int i:array)
		{
			System.out.print(i+" ");
		}
	}
}

//选择排序类
class SelectSort extends ParentSort
{
	@Override
	public void sort(int[] array)
	{
		int index;
		for(int i=1;i<array.length;i++)
		{
			index = 0;
			for(int j=1;j<=array.length-i;j++)
			{
				if(array[j]>array[index])
				{
					index=j;
				}
			}
			int temp = array[array.length-i];
			array[array.length-i] = array[index];
			array[index] = temp;
		}
		System.out.print("选择排序：");
		showArray(array);
	}
}

//插入排序类
class InsertSort extends ParentSort
{
	@Override
	public void sort(int[] array)
	{
		for(int i=0;i<array.length;i++) 
		{
			 int j = i - 1;
			 int temp = array[i];   //记录要插入的数据  
			 while(j>=0 && array[j]>temp)  //从后向前，找到比其小的数的位置 
			 {
				 array[j+1] = array[j]; //向后挪动  
				 j--;
			 }
			 if(j != i-1) //存在比其小的数 
			 {
				 array[j+1] = temp;
			 }
		}
		System.out.print("插入排序：");
		showArray(array);
	}
}

//快速排序类
class FastSort extends ParentSort
{
	@Override
	public void sort(int[] array)
	{
		int left = 0;
		int right = array.length-1;
		sort(array,left,right);
		System.out.print("快速排序：");
		showArray(array);
	}
	
	public void sort(int[] array,int left1,int right1)
	{
		int left = left1;
        int right = right1;
        int temp = 0;
        if(left <= right) //待排序的元素至少有两个的情况
        {  
            temp = array[left];  //待排序的第一个元素作为基准元素
            while(left != right)//从左右两边交替扫描，直到left = right
            {   
                while(right > left && array[right] >= temp)  
                     right --;        //从右往左扫描，找到第一个比基准元素小的元素
                  array[left] = array[right];  //找到这种元素array[right]后与array[left]交换

                while(left < right && array[left] <= temp)
                     left ++;         //从左往右扫描，找到第一个比基准元素大的元素
                  array[right] = array[left];  //找到这种元素array[left]后，与array[right]交换

            }
            array[right] = temp;    //基准元素归位
            
            sort(array,left1,left-1);  //对基准元素左边的元素进行递归排序
            sort(array,left+1,right1);  //对基准元素右边的进行递归排序
        }
	}
}

//策略类
class Factory
{
	private ParentSort sort;
	//依赖注入 
	public void setSort(ParentSort sort)
	{
		this.sort = sort;
	}
	public void doSort(int[] array)
	{
		sort.sort(array);
	}
}

//测试类
public class SortTest
{
	public static void main(String[] args) 
	{
		int[] array = {63,4,24,1,3,15};
		Factory factory = new Factory();
		
		System.out.println("1、选择排序");
		System.out.println("2、插入排序");
		System.out.println("3、快速排序");
		
		System.out.print("请选择：");
		Scanner input = new Scanner(System.in);
		int number = input.nextInt();
		
		if(number == 1)
		{
			ParentSort selectSort = new SelectSort();
			factory.setSort(selectSort);
			factory.doSort(array);
		}
		
		if(number == 2)
		{
			ParentSort insertSort = new InsertSort();
			factory.setSort(insertSort);
			factory.doSort(array);
		}
		
		if(number == 3)
		{
			ParentSort fastSort = new FastSort();
			factory.setSort(fastSort);
			factory.doSort(array);
		}
	}
}

Ctrl+F 删除java注释:  /\*{1,2}[\s\S]*?\*/

Ctrl+F 删除xml注释:  <!-[\s\S]*?-->

Ctrl+F 删除空白行:   ^\s*\n

Ctrl+F 删除代码中的注释和空行:   /\*{1,2}[\s\S]*?\*/|\/\/.+|^\s*\n

勾选 Regular expressions 选择正则表达式  ，替换replaceAll全部即可。

public static int[] copyOf(int[] original, int newLength) {
    	 int[] copy = new int[newLength];
    	 System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));
         return copy;
}

import java.util.Arrays;

/**
  * @author wrh
  */
 public class Test {
     public static void main(String[] args) {
         int[] array1 = {1,2,3,4,5};
        
         // 1.通过for循环
         int[] array2 = new int[5];
         for(int i = 0;i < array1.length;i++) {
             array2[i] = array1[i];
         }
         for(int i = 0;i < array2.length;i++) {
             System.out.print(array2[i]);
         }
         System.out.println();
         
         //2.通过System.arraycopy()
         int[] array3 = new int[5];
         System.arraycopy(array1, 0, array3, 0, 5);
         for (int i = 0; i < array3.length; i++) {
             System.out.print(array3[i]);
         }
         System.out.println();
         
         //3.通过Arrays.copyOf()
         int[] array4 = new int[5];
         array4 = Arrays.copyOf(array1, 5);
         for (int i = 0; i < array4.length; i++) {
             System.out.print(array4[i]);
         }
         System.out.println();
         
         //4.通过Object.clone()
         int[] array5 = new int[5];
			array5 = array4.clone();
         for (int i = 0; i < array5.length; i++) {
             System.out.print(array5[i]);
        }
	}
}

//创建对象  
        Date date = new Date() ;  
        Cookie c = new Cookie("lastVisited",date.toString()) ;  
//设定有效时间  以s为单位  
        c.setMaxAge(60) ;  
//设置Cookie路径和域名  
        c.setPath("/") ;  
        c.setDomain(".zl.org") ;  //域名要以“.”开头  
//发送Cookie文件  
        response.addCookie(c) ;  
//读取Cookie  
        Cookie cookies[] = request.getCookies() ;  
        Cookie c1 = null ;  
        if(cookies != null){  
            for(int i=0;i<cookies.length;i++){  
               c1 = cookies[i] ;  
               out.println("cookie name : " + c1.getName() + "   ") ;  
               out.println("cookie value :" + c1.getValue() + "<br>");  
            }  
        }  
  //修改Cookie  
       Cookie cookies[] = request.getCookies() ;  
       Cookie c = null ;  
       for(int i=0;i<cookies.length;i++){  
           c = cookies[i] ;  
           if(c.getName().equals("lastVisited")){  
              c.setValue("2010-04-3-28") ;  
              c.setMaxAge(60*60*12) ;  
              response.addCookie(c) ;     //修改后，要更新到浏览器中       
           }  
       }  
   
//删除Cookie,(将Cookie的有效时间设为0)  
       Cookie cookies[] = request.getCookies() ;  
       Cookie c = null ;  
       for(int i=0;i<cookies.length;i++){  
           c = cookies[i] ;  
           if(c.getName().equals("lastVisited")){  
              c.setMaxAge(0);  
              response.addCookie(c) ;  
           }  
       }  

SetCookie.java :  
public void doPost(HttpServletRequest request, HttpServletResponse response)  
            throws ServletException, IOException {  
   
        response.setContentType("text/html;charset=utf-8");  
        PrintWriter out = response.getWriter();  
        String username = request.getParameter("username") ;  
        //保存Cookie  
        if(username !=""){  
            Cookie c1 = new Cookie("username",username) ;  
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd") ;  
            Cookie c2 = new Cookie("lastVisited",sdf.format(new java.util.Date())) ;  
            c1.setMaxAge(60*60*60*12*30) ;  
            c2.setMaxAge(60*60*60*12*30) ;  
            response.addCookie(c1) ;  
            response.addCookie(c2) ;  
            out.println("Cookie保存成功!");  
            out.println("<br><br>") ;  
            out.println("<a href=GetCookie02>读取Cookie</a>") ;  
        }else{  
            response.sendRedirect("../cookieInput.html") ;  
        }  
          
          
        out.flush();  
        out.close();  
    }  

GetCookie.java:  
public void doPost(HttpServletRequest request, HttpServletResponse response)  
            throws ServletException, IOException {  
   
        response.setContentType("text/html;charset=utf-8");  
        PrintWriter out = response.getWriter();  
        out.println("<!DOCTYPE HTML PUBLIC /"-//W3C//DTD HTML 4.01 Transitional//EN/">");  
        out.println("<HTML>");  
        out.println("  <HEAD><TITLE>A Servlet</TITLE></HEAD>");  
        out.println("  <BODY>");  
          
        //读取Cookie  
        Cookie cookies[] = request.getCookies() ;  
        Cookie c = null ;  
        if(cookies != null){  
            for(int i=0;i<cookies.length;i++){  
                c = cookies[i] ;  
                if(c.getName().equals("username")){  
                    out.println("用户名: "+c.getValue());  
                    out.println("<br>");  
                }  
                if(c.getName().equals("lastVisited")){  
                    out.println("上次登录的时间: "+c.getValue());  
                }  
            }  
        }else{  
            out.println("No cookie !");  
        }  
          
        out.println("  </BODY>");  
        out.println("</HTML>");  
        out.flush();  
        out.close();  
    }  

1、http://localhost:8080/jsp/
	http://HTTP协议
	localhost表示本地，如果访问其他主机的服务器，则替换为要访问主机的IP地址
	8080表示当前服务器的端口号
	/jsp表示要访问的项目(工程)的路径
	/表示要访问的页面的路径，当前为默认路径
2、http://localhost:8080/jsp/jsp/myNewJsp.jsp
	jsp/myNewJsp.jsp
		jsp表示自定义文件夹路径
		myNewJsp.jsp表示自定义jsp文件
3、jsp的九大内置对象
	注意：jsp页面中所有Java代码必须包裹在<%%>中
	一：out输出对象，将内容输出到页面上
	二：request表示一次请求
		1、相对路径
			request.getRequestDispatcher("jie.jsp").forward(request,response);
		2、绝对路径
			request.getRequestDispatcher("/jsp/request/jie.jsp").forward(request,response);
		表示请求转发，使请求转发到指定页面，该行为为服务器行为（一次请求）
		getRequestDispatcher("requestJie.jsp")指定要去的页面，参数为String类型的路径
		forward(request,response)表示将当前请求中所含的信息一起转发
		特点：浏览器地址栏内容不变
	三：response表示重定向,响应对象
		1、相对路径
			response.sendRedirect("jie.jsp");
		2、绝对路径
			response.sendRedirect(request.getContextPath()+"/jsp/jieChuan/jie.jsp");
			request.getContextPath()表示获取当前项目在服务器上的路径
		表示重定向，使请求重新定向到新的请求或页面，还行为为浏览器行为（两次请求）
		sendRedirect("jie.jsp")表示设置重定向路径
		特点：浏览器地址栏内容改变(页面真实路径)
		http://localhost:8080/jsp/jsp/request/jie.jsp
	***注意：使用重定向跳转页面（请求）时，request不能传递值
	四：session表示浏览器级别作用域,会话对象
		作用：存储键值对，方便后续取用
		范围：浏览器级别，只要浏览器不关闭，当前session一直有效
	五：application表示服务器级别的作用域，上下文
		作用：存储键值对，方便后续取用
		范围：服务器级别，只要服务器不关闭，当前application一直有效
	最后四个：page		pageContext		config		exception
	
4、四大作用域
	page	request		session		application


5、Java代码和HTML代码结合使用
	可以将Java代码前后分离,只要所有<%%>连接起来，Java代码整齐就行，在%>HTML代码<%中间书写HTML代码
	如果需要对Java变量进行输出，则需要将Java变量使用<%=变量%>包裹
6、el表达式
	写法：${键}
	作用：接收三大作用域中传递的值
	顺序：当三大作用域同时传递同样的键时，request>session>application


7、HTML表单（form）提交方式
	get：显式提交	有body部分，所有参数名称和参数值(参数名称=参数值)显示在浏览器地址栏中
	post：隐式提交	没有body部分，表单元素组成的参数名称和参数值不显示在浏览器地址栏中
	注意***：表单元素组成的参数名称和参数值：表单元素的name属性值作为参数名称，value属性值做参数值
8、中文乱码		
	隐式提交：使用request.setCharacterEncoding("utf-8");可解决
	注意：以上方式中，转码方法必须放在第一行
	显式提交：new String(hua.getBytes("utf-8"),"iso8859-1");终极转码方式