//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("不相等");
}
}
}
// ===================