java basic

//java 声明常量
//final 数据类型 常量名=值;
//as:
final float PI=3.14f;/  PI=3.14002F
//默认浮点为 double

//break：跳出多重循环，可用 break label(标签名)
//as:
public class Hi
{
   public static void main(String[] args)
   {
     int i = 5;
     label01:
     for(int j = 0; j < i; j++)
     {
        System.out.println("j值为:"+j);
	for(int k = 0; k < 5; k++)
	{
	   System.out.println("k值为："+k);
	   if(k == 4)
	   {
	      break label01; //直接跳出，执行后面的输出 end
	   }
	}
     }
     System.out.println("end"); // 可以从 break label01; 语句中直接跳到这里
   }
}

/**
数组声明方法：
as1:
数据类型 数组名[] = null;
数组名 = new 数组类型[数组长度]
as:
*/
int arr[] = null;
arr = new int[3];
/**
以上还可以写成:
数据类型 数组名[];或者 数据类型[] 数据名;
as:
*/
int arr[];
arr = new int[4];
//或者：
int[] arr;
arr = new int[4];
//==============================
/**
as2:
数据类型 数组名[] = new 数组类型[数组长度];
as:
*/
int arrs[] = new int[5];
//========================
/**
数组的静态初始化:
as1:
数据类型 数组名[] = {元素值,元素值};
as:
*/
int arr[] = {1,2,3};
//===================
/**
as2:
数据类型 数组名[] = new 数据类型[]{元素值，元素值...};
as:
*/
String arrs[] = new String[]{"a","b","abc"};

//数组的动态初始化:
int arr = new int[4];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
//或者：
String arr[];
arr = new String[2];
arr[0] = "aaaa";
arr[1] = "bbbb";
//--------------------
/**

不能同时静态化与动态化结合
as:(出错)
*/
String arr[] = new String[4]{"a","b","c","d"};
//==========
//数组的长度, 数组名.length
// as:
arr.length;
// foreach语法
/**
for(数组类型 形参:数组名)
{
	// 循环体
}
*/
// as:
String str[] = new String[]{"a","b","c"};
for(String lang:arr)
{
	System.out.println(lang); // 逐个输出数组元素
}
// ----------------

/**
输入五个数，找到最大的
*/
import java.util.Scanner;
public class Hi
{
	public static void main(String[] args)
	{
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入五个数：");
		int arr[] = new int[5];
		int min;
		for(int i =0; i<5; i++)
		{
			arr[i] = scan.nextInt();
		}
		min = arr[0];
		for(int i=1;i<5;i++)
		{
			if(arr[i] > min)
			{
				min = arr[i];
			}
		}
		System.out.println("max:"+min);
	}
}
//==================
// 冒泡法
public class Hi
{
	public static void main(String[] args)
	{
		int arr[] = {234,654,346,983,235,327};
		int temp;
		System.out.println("原排序为：");
		for(int i=0; i<arr.length; i++)
		{
			System.out.print(arr[i]+" ");
		}
		System.out.println();
		for(int i=0; i< arr.length; i++)
		{
			for(int j=0; j<arr.length-1; j++)
			{
				if(arr[j] < arr[j+1])
				{
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
			System.out.println("第 "+i+" 次冒泡排序：");
			for(int kk=0; kk < arr.length; kk++)
			{
				System.out.print(arr[kk]+" ");
			}
			System.out.println();
		}
		System.out.println("最后的排序为：");
		for(int k=0; k<arr.length; k++)
		{
			System.out.print(arr[k]+" ");
		}
		System.out.println();
	}
}
/**
原排序为：
234 654 346 983 235 327
第 0 次冒泡排序：
654 346 983 235 327 234
第 1 次冒泡排序：
654 983 346 327 235 234
第 2 次冒泡排序：
983 654 346 327 235 234
第 3 次冒泡排序：
983 654 346 327 235 234
第 4 次冒泡排序：
983 654 346 327 235 234
第 5 次冒泡排序：
983 654 346 327 235 234
最后的排序为：
983 654 346 327 235 234
*/
// =======================
//-------------------
// 插入排序
public class Hi
{
	public static void main(String[] args)
	{
		int arr[] = {323,764,871,984,678,541};
		int temp;
		System.out.println("原排序：");
		for(int i=0; i<arr.length; i++)
		{
			System.out.print(arr[i]+" ");
		}
		System.out.println();
		// 插入法
		for(int j = 1; j<arr.length; j++)
		{
			for(int k = j; k > 0; k--)
			{
				if(arr[k] > arr[k-1])
				{
					temp = arr[k];
					arr[k] = arr[k-1];
					arr[k-1] = temp;
				}
			}
			System.out.println("第几次插入 "+j+" 次");
			for(int k=0; k<arr.length; k++)
			{
				System.out.print(arr[k]+" ");
			}
			System.out.println();
		}
		System.out.println("最后的排序:");
		for(int k=0; k<arr.length; k++)
		{
			System.out.print(arr[k]+" ");
		}
	}
/**
原排序：
323 764 871 984 678 541
第几次插入 1 次
764 323 871 984 678 541
第几次插入 2 次
871 764 323 984 678 541
第几次插入 3 次
984 871 764 323 678 541
第几次插入 4 次
984 871 764 678 323 541
第几次插入 5 次
984 871 764 678 541 323
最后的排序:
984 871 764 678 541 323
*/
// ====================
// --------------------
// 选择排序
public class Hi
{
	public static void main(String[] args)
	{
		int arr[] = {342,567,984,321,498,876,769};
		System.out.println("原排序为：");
		for(int i=0; i<arr.length; i++)
		{
			System.out.print(arr[i]+" ");
		}
		System.out.println();
		for(int i = 0; i<arr.length; i++)
		{
			int temp = i;
			for(int j = i+1; j < arr.length;j++)
			{
				if(arr[j] > arr[temp])
				{
					temp = j;
				}
			}
			int tt = arr[i];
			arr[i] = arr[temp];
			arr[temp] = tt;
			System.out.println("第 "+(i+1)+" 次：");
			for(int kk =0; kk<arr.length; kk++)
			{
				System.out.print(arr[kk]+" ");
			}
			System.out.println();
		}

		System.out.println("最终排序：");
		for(int kk=0; kk<arr.length; kk++)
		{
			System.out.print(arr[kk]+" ");
		}
	}
}

/**
原排序为：
342 567 984 321 498 876 769
第 1 次：
984 567 342 321 498 876 769
第 2 次：
984 876 342 321 498 567 769
第 3 次：
984 876 769 321 498 567 342
第 4 次：
984 876 769 567 498 321 342
第 5 次：
984 876 769 567 498 321 342
第 6 次：
984 876 769 567 498 342 321
第 7 次：
984 876 769 567 498 342 321
最终排序：
984 876 769 567 498 342 321
*/

=======================================
//快速排序
public class Hi
{
    public static void main(String[] args)
    {
        int arr = Array[];//数组
        int y = Array[10];
        y = quickSort(arr);
        for(int i=0; i<10;i++)
        {
            System.out.println(y[i]);
        }
    }
    public static Array quickSort(Array arr)
    {
        if(arr.length > 1)
        {
            int key = arr[0];
            int x = Array[10];
            int y = Array[10];
            for(int i = 0; i < arr.length;i++)
            {
                if(arr[i] < key)
                {
                    x[] = arr[i];
                }else if(arr[i] > key)
                {
                    y[] = arr[i];
                }
            }
            x = quickSort(x);
            y = quickSort(y);
            return x+key+y; // 组合
        }else
        {
            return arr;
        }
    }
}

// ----------------
//数据类型 数组名[][]
//数据类型[][] 数组名
//数据类型[] 数组名称[]

// 静态赋值，必须和声明在一起
public class Hi
{
	public static void main(String[] args)
	{
		int arr[][] = {{1,2}, {3,4}, {5,6}};
		String str[][] = new String[][]{{"aa", "bb"}, {"cc", "dddd"}};
		for(int i=0; i<2; i++)
		{
			for(int j=0; j<2; j++)
			{
				System.out.print(arr[i][j]+" ");
			}
		}
		System.out.println();
		for(int k=0; k<2; k++)
		{
			for(int kk=0; kk<2; kk++)
			{
				System.out.print(str[k][kk]+" ");
			}
		}
		System.out.println();
	}
}
// ===================
// ---------------------
// 动态声明
//数据类型 数组名[][] = new 数据类型[rows][cols]
public class Hi
{
	public static void main(String[] args)
	{
		int arr[][] = new int[2][2];
		String[][] str = new String[2][2];
		arr = new int[][]{{2,1}, {3,4}};
		str = new String[][]{{"aa", "bb"},{"cc", "dd"}};
		for(int i=0; i<2; i++)
		{
			for(int j=0; j<2; j++)
			{
				System.out.print(arr[i][j]+" ");
			}
		}
		System.out.println();
		for(int k =0; k<2; k++)
		{
			for(int kk=0; kk<2; kk++)
			{
				System.out.print(str[k][kk]+" ");
			}
		}
		System.out.println();
	}
}

// ==================
// -----------------
/**
 * 搜索值在数组中的位置
 * sort(Array) 对数组升排序
 * binarySearch(Array, value) 对升序的数组查找 value值所在的位置
 */
import java.util.Arrays;
import java.util.Scanner;
public class Hi
{
	public static void main(String[] args)
	{
		Scanner scan = new Scanner(System.in);
		System.out.println("输入一个数:");
		int searchInt = scan.nextInt();
		int arrInt[] = {1,20,33,4};
		Arrays.sort(arrInt);
		int search = Arrays.binarySearch(arrInt, searchInt);
		System.out.println("数组排序后：");
		for(int i=0; i<arrInt.length; i++)
		{
			System.out.print(arrInt[i]+" ");
		}
		System.out.println();
		if(search >= 0)
		{
			System.out.println("位置为:"+(search+1));
		}else
		{
			System.out.println("找不到");
		}
	}
}
/**
输入一个数
20
数组排序后
1 4 20 33
位置为:3
*/
// ===================
// ------------------
/**
 * copyOf(array, position) 从 0 到 position 的位置长度
 * copyOfRange(Array, position, position1) 从位置 position 取到 pos1tion1
 */
import java.util.Arrays;
public class Hi
{
	public static void main(String[] args)
	{
		int arr[] = {1,2,3,4,5,6,7,8};
		int arrs[] = Arrays.copyOf(arr,3);
		int arrss[] = Arrays.copyOfRange(arr,2,5);
		System.out.println("copyOf方法的取值：");
		for(int i=0; i<arrs.length; i++)
		{
			System.out.print(arrs[i]+" ");
		}
		System.out.println();
		System.out.println("copyOfRange方法取值：");
		for(int k=0; k<arrss.length; k++)
		{
			System.out.print(arrss[k]+" ");
		}
		System.out.println();
	}
}

/**
copyOf方法的取值：
1 2 3
copyOfRange方法取值：
3 4 5
*/
// ===============
// -------------------
/**
 * equals 比较两数组是否相等
 */
import java.util.Arrays;
public class Hi
{
	public static void main(String[] args)
	{
		int arr[] = {1,2,3,4,5,6};
		int arr1[] = {1,2,3,4,5,6};
		int arr2[] = {1,2,3};
		System.out.println("equals 比较两数组是否相等");
		System.out.println("两数组比较："+Arrays.equals(arr,arr1));
		System.out.println("两数组比较："+Arrays.equals(arr, arr2));
	}
}
/*
equals 比较两数组是否相等
两数组比较：true
两数组比较：false
*/
// ==============
//--------------
/**
 * 方法声明,必须包含在类中
访问控制符 [修饰符] 返回值类型 方法名(参数类型 参数1,参数类型 参数2,..)
{
	代码段;
	[return 返回值];
}
访问控制符:public,protected,private,default
修饰符: static final,abstract,synchronized,native
*/
public class Hi
{
	public static void main(String[] args)
	{
		int a=1;
		int b = tt(a);
		int c = tt(a,b);
		System.out.println(b);
		System.out.println(c);
	}
	// 这是方法，必须包含在类中
	public static int tt(int a)
	{
		a += 100;
		return a;
	}

	public static int tt(int a, int b)
	{
		int c = a+b;
		return c;
	}
}
// ===================
//-----------------begin
// 可变参数 类型 ... 变量名,其中的参数是以数组的形式传入的
public class Hi
{
	public static void main(String[] args)
	{
		tt("a");
		tt("aa", "bb");
		tt("aaa", "bbb", "ccc");
		t(1, "a1111");
		t(2, "b2222");
	}
	// 可以参数类型相同时
	public static void tt(String ... str)
	{
		for(String ss:str)
		{
			System.out.print(ss+" ");
		}
		System.out.println();
	}
	// 可变参数类型不同时，可变的类型放最后
	public static void t(int i, String...str)
	{
		System.out.println(i);
		for(String ss:str)
		{
			System.out.print(ss+" ");
		}
		System.out.println();
	}

}
//===============end
//------------
// 因为可变参数是以数组的形式传递的，所以可用数组的形式表示
// 可变参数 以数组的形式传，参数的顺序不论
public class Hi
{
	public static void main(String[] args)
	{
		int i = 10;
		String aa[] = {"aa", "bb", "cc"};
		int ii[] = {1,2,3};
		tt(i, aa);
		tt(ii, aa);
	}
	// 以数组的形式传
	public static void tt(int i, String[] str)
	{
		System.out.println(i);
		for(String a:str)
		{
			System.out.print(a+" ");
		}
		System.out.println();
	}

	public static void tt(int[] i, String[] str)
	{
		for(int ii:i)
		{
			System.out.print(ii+" ");
		}
		System.out.println();
		for(String s:str)
		{
			System.out.print(s+" ");
		}
		System.out.println();
	}
}
// =====================
// ---------------
// 因为可变参数是以数组的形式传递的，所以可用混合数组的形式表示
public class Hi
{
	public static void main(String[] args)
	{
		int i = 10;
		String aa[] = {"aa", "bb", "cc"};
		tt(i, aa);
	}
	// 以混合数组的形式传
	public static void tt(int i, String...str)
	{
		System.out.println(i);
		for(String s:str)
		{
			System.out.print(s+" ");
		}
	}
}
//=======================
//----------
//String 作为一个特殊的类,可直接使用
//也可用 new String();
//两种初始化
// 方法1： String 变量名 = "字符串";
// 方法2:  String 变量名 = new String("字符串");
// 有区别的,方法1中先去找缓存池中有没有相关的，有则取， 无则重新生成，方法是直接重新生成
// == 比较是内存地址的值
public class Hi
{
	public static void main(String[] args)
	{
		String s1 = "aa";
		String s2 = "aa";
		String s3 = new String("aa");
		String s4 = s3;
		if(s1==s2)
		{
			System.out.println("s1=s2:true");
		}else
		{
			System.out.println("s1=s2:false");
		}

		if(s3 == s4)
		{
			System.out.println("s3=s4:true");
		}else
		{
			System.out.println("s3=s4:false");
		}
		if(s1 == s3)
		{
			System.out.println("s1=s3:true");
		}else
		{
			System.out.println("s1=s3:false");
		}
	}
}
/**
s1=s2:true
s3=s4:true
s1=s3:false
*/
// =================
//------------
//String 作为一个特殊的类,可直接使用
//也可用 new String();
//两种初始化
// 方法1： String 变量名 = "字符串";
// 方法2:  String 变量名 = new String("字符串");
// 有区别的,方法1中先去找缓存池中有没有相关的，有则取， 无则重新生成，方法是直接重新生成
// equals 比较值是否相等
public class Hi
{
	public static void main(String[] args)
	{
		String s1 = "aa";
		String s2 = "aa";
		String s3 = new String("aa");
		String s4 = s3;
		if(s1.equals(s2))
		{
			System.out.println("s1=s2:true");
		}else
		{
			System.out.println("s1=s2:false");
		}

		if(s3.equals(s4))
		{
			System.out.println("s3=s4:true");
		}else
		{
			System.out.println("s3=s4:false");
		}
		if(s1.equals(s3))
		{
			System.out.println("s1=s3:true");
		}else
		{
			System.out.println("s1=s3:false");
		}
	}
}
/**
s1=s2:true
s3=s4:true
s1=s3:true
*/// ===============
//---------------
// string 类是不可变的，所以要不断改变，就得不断重新生成，这样消耗资源，为此，提供了可变的类 StringBuffer类
/**
创建StringBuffer格式1：
StringBuffer 对象名=null;
对象名 = new StringBuffer("字符串");

格式2:
StringBuffer 对象名 = new StringBuffer("字符串");
*/
public class Hi
{
	public static void main(String[] args)
	{
		StringBuffer str = null;
		str = new StringBuffer("this is StringBuffer1");
		StringBuffer str1 = new StringBuffer("this is StringBuffer 2");
		System.out.println(str);
		System.out.println(str1);
	}
}
// =====================

// -------------
// string  常的方法
public class Hi
{
	public static void main(String[] args)
	{
		// 从字符串中提取指定位置的字符
		String str = "Hello World";
		char s = str.charAt(6);
		System.out.println(s); // W

		 //判断是否以指定的字符串开头和结尾
		 System.out.println(str.startsWith("Hello")); // true
		 System.out.println(str.startsWith("hi"));   // false
		 System.out.println(str.endsWith("ld"));     // true
		 System.out.println(str.endsWith("dd"));     // false

		 // 比较字符串，不区分大小不一写
		 String str1 = "hello world";
		 System.out.println(str.equalsIgnoreCase(str1)); // true

		 // 将字符串变了字符数组，再将字符数组转为字符串
		 char arr[] = str.toCharArray(); // 将字符转为数组
		 for(int i=0; i<arr.length; i++)
		{
			System.out.print(arr[i]+" ");
		}
		System.out.println();
		String ss = String.valueOf(arr); // 将字符数组转为字符串
		System.out.println(ss);

		System.out.println(str.indexOf("ll")); // 寻找指定的字符串是否存在

		System.out.println(str.length()); // 获取指定的字符串的长度

		String sss = str.replace('H', 'a'); // 将指定的字符转为别的字符
		System.out.println(sss);

		String ssss = str.replaceAll("Hello", "hi"); // 将指定的字符串转为指定的字符串

		String ok[] = str.split(" "); // 用指定的字符串分拆字符串成数组

		String oo = str.substring(1,3); // 从指定的位置到指定的位置截取 (el), 默认截取到最后
		System.out.println(str.toUpperCase()); // 转为大写
		System.out.println(str.toLowerCase()); // 转为小写
		System.out.println(str.trim()); // 去两边空格
	}
}
// =====================

// ------------
// StringBuffer 基本操作方法
public class Hi
{
	public static void main(String[] args)
	{
		StringBuffer str = new StringBuffer("java");
		StringBuffer ss = new StringBuffer();
		StringBuffer sss = new StringBuffer(3);
		StringBuffer str1 = new StringBuffer("abcefgh");
		// 连接字符串，只能用 append(),不能用 "+"
		str.append("3");
		str.append("版本");
		System.out.println(str); // java3版本

		// 获取 StringBuffer容量大小,默认为16,如果初始化指定了大小，则为16+字符串大小
		System.out.println(str.capacity()); // 20，等于 16+4
		System.out.println(ss.capacity()); // 16
		sss.append("aaaaaaaaaa");
		System.out.println(sss.capacity()); // 10,这是因为sss指定为3,但是字符串长度为10，如果指定的(长度+1) *2 < 字符长度，则取 字符串长度,不然就取 (长度+1) *2值

		// 删除字符
		System.out.println(str1.delete(1,2)); // 删除了b, 结果为 acefgh
		//也可用 deleteCharAt()，删除单个字符
		System.out.println(str.deleteCharAt(1)); // jva3版本

		// append 只能从最后追加字符串，insert()可从任意位置追加
		StringBuffer ok = new StringBuffer("abc");
		ok.insert(1,"小二"); // 从索引位置1开始追加
		System.out.println(ok);  // a小二bc
		// 反转字符串
		System.out.println(ok.reverse()); // cb二小a

		// 指定的字符替换为指定的字符串
		StringBuffer s = new StringBuffer("lin3615");
		s.setCharAt(0, '林');
		System.out.println(s); // 林in3615

		// 设置长度
		s.setLength(3);
		System.out.println(s); // 林in ,会截取超过的长度

		//StringBuffer没有 string equals(),但可以先转为字符再比较 .toString();
		StringBuffer sb = new StringBuffer("java");
		StringBuffer sb1 = new StringBuffer("java");
		// 以下结果为不相等
		if(sb.equals(sb1))
		{
			System.out.println("相等");
		}else
		{
			System.out.println("不相等");
		}

		// 以下结果为相等
		if(sb.toString().equals(sb1.toString()))
		{
			System.out.println("相等");
		}else
		{
			System.out.println("不相等");
		}
	}
}
// ===================