java学习笔记day4

java学习笔记day4

今天的主要内容是循环，数组，加上一些算法题 by2019/06/4

一：什么是数组，什么时候使用数组？

数组是用来保存一组数据类型相同的元素的有序集合，
数组中的每个数据称为元素。
有序集合可以按照顺序或者下标取数组中的元素
在Java中，数组也是Java对象。数组中的元素可以是任意类型(
包括基本类型和引用类),但同一个数组里只能存放类型相同的元素。

二：什么时候用数组？

1)保存一堆数据类型相同的数据的时候
2)数据要求有顺序

三：数组和链表的区别

a)在内存开辟难易程度上？
数组内存分配必须是一块连续的内存空间。
链表内存分配不一定是连续的内存空间。
b)在项目中如何选择？
项目重点在数据的增删改，选择链表。不需要数据的大量搬移
项目重点在数据的查询，选择数组，检索效率非常高。

四：创建数组大致包括如下步骤：

package com.briup.ch04;

/**

- 测试基本数据类型的数组

- @author 13749
  *
   */
  public class ArrayTest1 {

  public static void main(String[] args) {
    // TODO Auto-generated method stub
    

//申明数组
int[] array; //int array[]; 动态初始化 能分开写
int[] array2 = {1,2,3,4}; //静态初始化 不能分开写
int[] array3 = new int[] {1,2,3,4}; //静态初始化 不能分开写
//创建数组对象
array = new int[5]; //创建数组对象后 还会给数组的每个元素赋默认值

//给数组中的元素赋值（元素有下标从0开始）
array[0] = 10;
array[1] = 11;
array[2] = 12;
array[3] = 13;
array[4] = 14;

//遍历数组
for(int i = 0; i<array.length; i++) {
System.out.print(array[i]+"\t");
}
```

​
}

}

. 声明一个数组类型的引用变量，简称为数组变量；
. 用new语句构造数组的实例。new语句为数组分配内存，并且为数组中的每个元素赋予默认值；
. 初始化，即为数组的每个元素设置合适的初始值。
  a)数组变量的声明；
    1) 一个存放同一类型数据的集合
       a. 即可以是基本类型，也可以是对象类型；
       b. 数组中的每个数据为元素；
    2) 数组是一个对象，成员是数组长度和数组中的元素;
    3) 申明了一个数组变量并不是创建了一个对象;
    4) 申明数组的方式;
       int[] IArray 或者 int IArray[] 基本数据类型数组，
                    数组中存放的是基本数据类型。
       Teacher[] tArray 或者 Teacher tArray[]类数组，
                    数组中存放的是Teacher类创建的若干个的对象。
    注意：1) 声明数组变量的时侯，不能指定数组的长度，以下声明方式是非法的。
             int x[1];
             int[2] x;
   b)初始化数组
    初始化：自变量创建后首次赋值的过程；
      创建数组对象；数组对象和其他Java对象一样，也用new语句创建；
       int[] iArray = new int[2];
       new语句执行以下步骤：
       a. 在堆区中为数组分配内存空间，以上代码创建了一个包含2个元素的int数组；
          每个元素都是int类型，占4个字节，因此整个数组对象在内存中占用8个字节。
       b. 为数组中的每个元素赋予其数据类型的默认值。
          byte/short/int/long   0
          float         0.0f
          double                0.0d
          String                null
          char                '\u0000'
          boolean               false
       c. 返回数组对象的引用
  c)初始化数组对象；       
       数组中的每个元素都有一个索引，或者称为下标。
       数组中的第一个元素的索引为0，第二个元素的索引为1, 依次类推。
       通过索引可以访问数组中的元素或者给数组中元素内容赋值。
       1) 声明、创建、初始化分开： 
          int[] iArray;
          iArray = new int[2];
          iArray[0] = 0;
          iArray[1] = 1; 
       2) 声明、创建的同时并初始化数组；
          int[] iArray = {0, 1};
          Student sArray[] = new Student[] { 
                      new Student(“George”, “Male”, 20), new Student()};
          Student[] stArray = { new Student(), new Student()} ;

  注意：a. 非法的数组初始化方式：
       int[] x = new int[5]{5,4,3,2,1};//编译出错，不能在[]中指定数组的长度；
         int[] x;
         x = {5,4,3,2,1}; //{5,4,3,2,1}必须在声明数组变量的语句中使用，不能单独使用

## 五. 数组的边界：

​    1) 一个数组的下标从0开始，数组通过数组的对象引用变量的下标访问数组。
​       数组中第一个元素的索引为0, 第二元素的索引为1，
​       依次类推。如果一个数组长度是5，要访问最后一个数组元素可以通过
​       下标4来访问，如果通过下标5访问，超出了数组的边界，在运行时会抛出     
​       ArrayIndexOutOfBoundsException。

2) 通过调用数组的length方法可以获得一个数组的元素个数（数组长度）。
所有Java数组都有一个length属性，表示数组的长度. 该属性只能读取，但是不能修改。

## 六.排序问题

​    冒泡排序： 对两个相邻的数据进行比较，如果前一个数据比
​             后一个数据大，就交换位置，最多执行length-1趟
​         比较，每趟比较的次数最多为length-i-1
​     选择排序：每次把比较的第一个个数当做是最小数，如果找到后面有比
​       自己小的数，就记录位置，比较完之后交换这两个数
​       的位置。
​     使用java.util.Arrays中sort()方法和binarySearch()方法
​       Arrays.sort(数组的引用) ：进行排序
​       int Arrays.binarySearch(数组的引用,数据):
​              该数句在数组的下标.但是该方法
​         必须在数组排序之后使用。

## 七：二维数组（随机点名系统，学生的位置x,y）

   存放一维数组的数组
   int[][] a = new int[2][3];
   a[0].length
   a.length

   int[][]
   int[][][]
a)管理学生寝室
   管理每层楼学生的信息
   MultiArray.java      
b)输出方正矩形：
  0 2 2 2 2 2
  1 0 2 2 2 2
  1 1 0 2 2 2
  1 1 1 0 2 2
  1 1 1 1 0 2
  1 1 1 1 1 0

c)输出10行杨辉三角
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
............

锯齿形数组

## 八：System.arraycopy()

​    数组的长度一旦定义了，就无法修改。
​    所以需要arraycopy()来重新分配一个新的数组，
​    然后将其内容拷贝进去。
   int[] a = new int[5];
   int[] b = new int[5];
   a=b与System.arraycopy(a,0,b,0,5)有什么区别？
   比如说我将a[1]=2;请问b[1]的值是多少？

## 九：使用数组模拟队,先进先出

   1/3的需求分析
   1/3的coding
   1/3的测试
 class Queue(){
      //入队
      void add(int value){}
      //出队
      int remove(){}
      //当前队中元素个数
      int size()
      //输出类型
      void print()
 }

 class Student{}是以属性为主的类
 class Queue{}是以方法为主的类

## 十：可变长参数 ...  参数的个数可变

两个int相加?
public int add(int a,int b){}
三个int相加?
public int add(int a,int b,int c){}
四个int相加?
public int add(int a,int b,int c,int d){}
五个int相加?
public int add(int a,int b,int c,int d,int e){}
..........
上面的方案代码非常冗余。类似的代码重复写。
jdk1.5之前的解决方案：通过数组解决的
 public int add(int[] a){
 }

add(new int[]{5,8,9});
add(new int[]{5,8});

缺点:每次都要创建新的数组，
    创建数组需要在堆区开辟连续的内存空间。
    参数调用之后该变量就没用了，这样会
    浪费内存空间。
jdk1.5之后的解决方案：通过...解决的
 public int add(int... a){
 }
调用: add(1,4);
      add(1,4,6);
      add(7,6,8,89,76);

注意:1)可变长参数的使用和数组的使用是一样
     2)一个方法中只能定义一个可变长参数，
       并且要定义最后一个参数。

------

package com.briup.ch04;

public class Student
{
public int id;
public String name;
public int age;

public void print(){
System.out.println("------ Student ------");
System.out.println("id:" + id);
System.out.println("name:" + name);
System.out.println("age:" + age);
}

public Student(int sId, String sName, int sAge){
id = sId;
name = sName;
age = sAge;
}

}

package com.briup.ch04;

public class Teacher
{
public int id;
public String name;
public double salary;
public int clRoomId;
public int age;

public Teacher(){}

public Teacher(int id, String name, double salary, int clRoomId, int age){
    this.id = id;
    this.name = name;
    this.salary = salary;
    this.clRoomId = clRoomId;
    this.age = age;
}

public void print(){
    System.out.println("---- Teacher ----");
    System.out.println("id:" + this.id);
    System.out.println("name:" + name);
    System.out.println("salary:" + salary);
    System.out.println("classroom id:" + clRoomId);
    System.out.println("age:" + age);
}

}

package com.briup.ch04;

public class Classroom
{
public Teacher teacher; //保存教师
public Student[] students = new Student[40];//保存学生
public int index = 0; //保存学生数量

public Teacher getTeacher(){
    //返回教室中的教师
    return teacher;
}

public Student[] getStudents(){
    //返回所有的学生
    return students;
}

public void setTeacher(Teacher tea){
    //更换教师
    this.teacher = tea;
}

public void addStudent(Student stu){
    //增加学生
    students[index] = stu;
    index++;
}

public boolean removeStudent(int idx){
    //删除学生  第几个学生
    if(idx>index) {
        return false;
    }
    
    for(int i=idx-1; i<index-1; i++) {
        students[i] = students[i+1];
    }
    
    index--;
    return true;
}

public int getStudentNum(){
    //返回教室中学生的数量
    return index;
}

public void print(){
    //输出当前教室中的教师和学生的信息
    teacher.print();
    for(int i=0; i<index; i++) {
        students[i].print();
    }
}

}

package com.briup.ch04;

public class ClassroomTest
{
public static void main(String[] args)
{
//创建Classroom对象
Classroom cl =new Classroom();

    //创建Teacher对象，并将Teacher分配到Classroom中
    Teacher te = new Teacher(111, "度娘", 12000, 513, 22);
    cl.setTeacher(te);
    
    //创建3个Student对象，并将Student分配到Classroom中
    Student s1 = new Student(101, "jack", 22);
    Student s2 = new Student(102, "bill", 23);
    Student s3 = new Student(103, "matin", 21);
    cl.addStudent(s1);
    cl.addStudent(s2);
    cl.addStudent(s3);
    
    
    //调用Classroom中的其它方法，测试方法的业务逻辑是否准确

// 返回教室中的教师
// cl.getTeacher().print();

// 返回所有的学生
// Student[] students = cl.getStudents();
// for (int i=0; i<students.length; i++) {
// if(students[i]==null) {
// break;
// }
// students[i].print();
// }

// 更换教师
// cl.setTeacher(new Teacher(222, "小马哥", 1000, 513, 40));
// cl.getTeacher().print();

// 增加学生
// cl.addStudent(new Student(104, "mike", 19));
// cl.print();

// 删除学生
// if(cl.removeStudent(4)) {
// System.out.println("删除成功");
// }else {
// System.out.println("删除失败");
// }
// cl.print();

// 返回教室中学生的数量
// int studentNum = cl.getStudentNum();
// System.out.println("教室共有："+studentNum+"个学生");

// 输出当前教室中的教师和学生的信息
// cl.print();
}
}

```

嗯 今天还看了下swing 想在空余时间把图形化界面学了 ft