我的java日记(基础下)

今天又学到了很多东西,把以前一直不太明白的选择排序,冒泡排序和折半查找搞明白了,心中不由的产生一股动力, 因为在这个社会没有一技之长是无法立足的.所以我一定进入黑马学习. 只有学到了真正的东西,才能在社会上站稳脚跟.

一:Scanner类:从键盘上输出
   System.in:标准输入流
 例:
import java.util.Scanner;   //导包
class  ScannerTest
{
 public static void main(String[] args)
 {    //创建一个对象,指定从键盘输入
  Scanner sr=new Scanner(System.in);
  int num=sr.nextInt();//获取一个整型数据
  System.out.println("num="+num);
  Scanner sc=new Scanner(System.in);
  String str=sc.nextLine();
  System.out.println("输入的内容是:"+str);
 }
}

/*
通过Scanner对象获取数据注意:
如果先输入整数,再输入字符串则必须要再次实例化一个Scanner对象.
*/

二:数据的校验:
       1:正确数据
       2:边界数据
       3:错误数据

三:选择排序
 让0角标处的元素和其他的元素进行比较,第一次比较完后,最小值出现在了0角标位置.
 再让1角标处的元素和其后元素进行比较,比较完后,此小值出现在了1角标位置.
 依次类推,即可得到一个从小到大排序的数组.
例:class SelectDemo
{
 public static void main(String[] args)
 {
  int[] arr={12,23,45,223,4,2,452};
  System.out.println("排序前:");
  print(arr);
  selectsort(arr);
  System.out.println("\n排序后:");
  print(arr);
 }
 public static void selectsort(int[] a){
  int temp=0;
  //外循环控制比较次数
  for(int x=0;x<a.length-1;x++){
   //内循环控制元素的比较.
   //y=0,但是重复,所以y从1开始
   //下一次,x从1开始,那么,这时候又重复了.
   //经过观察,发现规律:y永远比x大1,所以最终确定y=x+1;
   for(int y=(x+1);y<a.length;y++){
    //数据比较
    if(a[x]>a[y]){
     //交换数据
     temp=a[x];
     a[x]=a[y];
     a[y]=temp;
    }
   }
  }
 }
 public static void print(int[] a){ //打印输出
  for(int i=0;i<a.length;i++){
    System.out.print(a[i]+"  ");
   }
 }
}

四:冒泡排序
相邻的元素两两比较,第一次比较完后,较大值出现在较大角标索引位置.
依次类推,就得到了一个从小到大排序的数组.
例:
class BubbleDemo
{
 public static void main(String[] args)
 {
  int[] arr={12,23,45,223,4,2,452};
  System.out.println("排序前:");
  print(arr);
  bubblesort(arr);
  System.out.println("\n排序后:");
  print(arr);
 }
 public static void bubblesort(int[] a){
  for(int x=0;x<a.length-1;x++){  //外循环控制比较次数
   for(int y=0;y<a.length-1-x;y++){  //length-1是为了防止y+1越界
    if(a[y]>a[y+1]){//数据的比较
     int temp=a[y];//交换数据
     a[y]=a[y+1];
     a[y+1]=temp;
    }
   }
  }
 }
 public static void print(int[] a){ //打印输出
  for(int i=0;i<a.length;i++){
    System.out.print(a[i]+"  ");
   }
 }
}
五:Arrays.sort();

五:查找数据:

  1:普通查找:
例;
//查找某个元素在数组中的角标
/*思路:就是遍历这个数组,然后把6和这个数组中的的元素进行比较,如果有满足条件的元素,就把其索引返回即可.
  1:6在数组中存在.
     返回第一个6的索引位置

  2:6在数组中不存在
     返回-1
*/
class SearchArray1
{
 public static void main(String[] args)
 {
  int arr[]={1,2,3,4,6,7};
  System.out.println("6的位置:"+search(arr,6));
 }
 public static int search(int[] arr,int value){
  int temp=-1;
  for(int i=0;i<arr.length;i++){
   if (arr[i]==value)
   {
    temp=i;
   }
  }
  return temp;
 }
}

//此中方法的查找效率很低.一般用于无序数组

.
2:折半查找(二分查找):
    前提:数组必须有序.
    注意:不能先对数组排序,再进行二分查找.
   例:
/*
折半查找:必须要求数组有序.
我们可以定义三个变量,用于保存数组的头索引,中间索引,尾索引.
int min=0;
int max=arr.length-1;
int middle=(min+max)/2;
int value     //要查找的值
如果value<middle,则在左半边找,max=middle-1,middle=(max+min)/2;
如果value>middle,max=middle+1,middle=(max+min)/2则在右半边查找.
依次类推就可以找到value值,
如果value值不存在则返回-1.
*/
class ZhebanSearch   //
{
 public static void main(String[] args)
 {
  int[] arr={12,23,32,45,56,67,78};
  
  System.out.println("要查找的内容是arr["+search(arr,56)+"]");
 }
 public static int search(int[] arr,int value){
  int min=0;
  int max=arr.length-1;
  int middle=(max-min)/2;
  while (arr[middle]!=value)
  {
   if(value>arr[middle]){
    min=middle+1;
   }else if(value<arr[middle]){
    max=middle-1;
   }
   if (min>max)
   {
    return -1;//如果小的索引比大的索引还大，那么，数据不存在。所以返回-1.
   }
   middle=(max+min)/2;
  }
  return middle;
 }
}

六:二维数组:数组中的数组,一维数组中的每一个元素又是一个一维数组.

 格式1:
    int[][] arr=new int[3][2];表示有三个一维数组,每个一维数组中又有2个元素.
  
 格式2:
    int[][] arr=new int[3][2];表示此二维数组中有三个一维数组,每个一维数组都是默认初始化值null,
    可以对这三个一维数组分别进行初始化.
    arr[0]=new int[1];
    arr[1]=new int[2];
    arr[2]=new int[3];
 格式3:
    int[][] arr={{1,2,4},{23,2},{7,45,6,3}};
    arr[0][2]={1,2,4};
    arr[1][]={23,2};
    arr[2][]={7,45,6,6};
  for(int i=0;i<arr.length;i++){
 for(int j=0;j<arr[i].length;i++){
  System.out.println(a[i][j]);
 }
  }