java中数组的定义及使用方法详解
数组：是一组相关变量的集合
数组是一组相关数据的集合，一个数组实际上就是一连串的变量，数组按照使用可以分为一维数组、二维数组、多维数组
数据的有点
不使用数组定义100个整形变量：int i1;int i2;int i3
使用数组定义 int i[100];
数组定义：int i[100];只是一个伪代码，只是表示含义的
一维数组
一维数组可以存放上千万个数据，并且这些数据的类型是完全相同的，使用java数组，必须经过两个步骤，声明数组和分配内存给该数组，声明形式一
声明一维数组：数据类型数组名[]=null;
非配内存给数组：数组名=new 数据类型[长度];
声明形式二
声明一维数组：数据类型 [] 数组名=null;
java数据类型分为两大类
基本数据类型
int、long操作的时候本身就是具体的内容
引用数据类型：数组、类、接口
引用传递的就是一个内存的使用权，一块内存空间，可能有多个人同
时使用
事例声明数组
package com.qn.array;
public class Test {
public static void main(String[] args) {
int score[]=null;//声明数组
score=new int[3];//开辟空间，大小为3
}
}
数组的声明格式里，数据类型是数组元素的数据类型，常见的有整形、浮点型、与字符型等
数组名是用来统一这组相同数据类型元素的名称，其命名规则和变量的相同
数组声明后实际上是在栈内存中保存了此数组的名称，结下了是要在堆内存中配置数组所需要的内存，齐产固定是告诉编译器，所声明的数组要存放多少个元素，而new 则是命令编译器根据括号里的长度
基本数据类型偶读有其默认值：int 0;只要是引用数据类型默认值就是null
事例
package com.qn.array;
public class Test {
public static void main(String[] args) {
int score[]=null;//声明数组
score=new int[3];//开辟空间，大小为3
System.out.print("score[0]="+score[0]);
System.out.print("\tscore[1]="+score[1]);
System.out.print("\tscore[2]="+score[2]);
}
}
堆栈内存的解释
数组操作中，在栈内存中保存的永远是数组的名称，只开辟了栈内的空间，数组是永远无法使用的，必须有指向的对内存才可以使用，要想开辟新对内存空间必须使用new关键字，之后就是将对内存的使用权交给对应的栈内存，而且一个堆内存空间可以同时被多个栈内存空间指向，比如一个人可以有多个名字，人就相当于对内存，名字就相当于栈内存
声明数组的同时分配内存空间
声明数组的同时非配内存
数据类型数组名[]=new 数据类型[个数]
int score[]=new int[10];
声明一个元素个数为10的整形数组score，同时开辟依靠内存空间
工期使用
java中，由于整形数据类型占用的空间为4个byte，而整个数组score 可保存的元素有10个。所以上例中占用的内存共有4*10=40个字节
数组的访问
数组中元素的表示方法
想要访问数组里的元素可以利用索引来完成，java的数组索引标号由10开始，以一个score[10]的整形数组为例，score[0]代表第一个元素
一直向下，最后一个为score[9]
取得数组的长度
在java中取得数组的长度（也就是数组元素的长度）可以利用数组名称.length完成，
数组名称.length--返回一个int类型的数据
package com.qn.array;
public class Test {
public static void main(String[] args) {
int score[]=null;//声明数组
score=new int[3];//开辟空间，大小为3
System.out.println(score.length);
}
}
结果
数组的静态初始化
之前的数组，所采用的都是动态初始化，所有的内容在数组声明的时候并不具体的指定，而是以默认值的形式出现
静态初始化是指在数组声明后直接为数组指定具体的内容
如果想要直接在声明的时候给数组赋初始值，可以采用大括号完成，只要在数组的生命格式后面加上初值的赋值即可，
数据类型数组名 []={初始值0,初始值1,初始值3，....初始值n}; package com.qn.array;
public class Test {
public static void main(String[] args) {
int score[]={1,2,3,4,5,6};//使用静态初始化声明数组
System.out.println(score.length);
}
}
结果
6
范例求出数组中的最大值和最小值
package com.qn.array;
public class Test {
public static void main(String[] args) {
int score[]={45,12,8,23,89,56};//使用静态初始化声明数组 int max=0;
int min=0;
max=min=score[0];
for (int i = 0; i < score.length; i++) {
if(score[i]>max){
max=score[i];
}
if(score[i]
min=score[i];
}
}
System.out.println("最大值:"+max);
System.out.println("最小值:"+min);
}
}
结果
范例排序，在操作中排序是比较常用的
从大到小
package com.qn.array;
public class Test {
public static void main(String[] args) {
int score[]={45,12,8,23,89,56};//使用静态初始化声明数组 int temp=0;
for (int i = 0; i < score.length; i++) {
for (int j = 0; j < score.length-1; j++) {
if(score[i]>score[j]){
temp=score[i];
score[i]=score[j];
score[j]=temp;
}
}
}
for (int i = 0; i < score.length; i++) {
System.out.print(score[i]+"\t");
}
}
}
结果
这个时候不要被i值所迷惑 if(score[i]>score[j]){
这一步主要知识为了比较，实际上完成之后输出的时候是根据j的值排序的
二维数组
如果可以把一维数组当做几何中的一条线图形，那么二维数组就相当于一个表格
A B
1 姓名年龄
2 齐宁 21
3 齐燕 23
4 齐威 26
二维数组声明的方式和以为数组的类似，内存分配也一样是用new这个关键字
其实声明与分配内存的格式如下
动态初始化
数据类型数组名[][];
数组名=new 数据类型[行的个数][列的个数];
声明并初始化数组
数据类型数组名[][]=new 数据类型[行的个数][列的个数];
静态初始化
二维数组的存储
声明二维数组score 同时开辟一段内存空间
int score[][]=new int[4][3];
整体数据score可保存的元素是4*3=12个，在java中，int数据类型所占用的空间为4个字节，因此该整形数组占用的内存共为4*12=48个字节
事例
package com.qn.array;
public class test1 {
public static void main(String[] args) {
int score[][] = new int[4][3];
score[0][1] = 30;
score[1][0] = 31;
score[2][1] = 32;
score[2][2] = 33;
score[3][1] = 34;
score[1][1] = 35;
for (int i = 0; i < score.length; i++) {
for (int j = 0; j < score[i].length; j++) {
System.out.print(score[i][j]+"\t");
}
System.out.println("");
}
}
}
结果
二维数组静态初始化
用到的时候才会开辟空间，不用的（红色部分）则不开辟空间多维数组
一般只是用到二维数组
三维数组简单了解
package com.qn.array;
public class test1 {
public static void main(String[] args) {
int score[][][]={
{
{5,1},{6,7}
},
{
{9,4},{8,3}
}
};
System.out.print(score[0][0][0]+"\t"); System.out.print(score[0][0][1]+"\t"); System.out.print(score[0][0][0]+"\t"); System.out.print(score[0][0][1]+"\t");
System.out.print(score[1][0][0]+"\t"); System.out.print(score[1][0][1]+"\t"); System.out.print(score[1][1][0]+"\t"); System.out.print(score[1][1][1]+"\t"); }
}
例如求平方根的(n)，求a的b次方(a, b)，求绝对值(n)等很多。下面是一些演示。publicclassMathTest { publicstaticvoidmain(String[]args) { intn=16; ？ 3)); ？ ？ } } publicclassMathDemo{ publicstaticvoidmain(Stringargs[]){ /** *abs求绝对值 */ 的时候会取偶数 */ // // // // // // // // // // /** *round四舍五入，float时返回int值，double时返回long值 */ //10 //11 //11 //11 //-10 //-11 //-11 //-10 } }
函数（方法） 描述 IEEEremainder(double,double) 按照IEEE754标准的规定，对两个参数进行余数运算。 abs(inta) 返回int值的绝对值 abs(longa) 返回long值的绝对值 abs(floata) 返回float值的绝对值 abs(doublea) 返回double值的绝对值 acos(doublea) 返回角的反余弦，范围在到pi之间 asin(doublea) 返回角的反正弦，范围在-pi/2到pi/2之间 atan(doublea) 返回角的反正切，范围在-pi/2到pi/2之间 atan2(doublea,doubleb) 将矩形坐标(x,y)转换成极坐标(r,theta) ceil(doublea) 返回最小的（最接近负无穷大）double值，该值大于或等于参数，并且等于某个整数cos(double) 返回角的三角余弦 exp(doublea) 返回欧拉数e的double次幂的值 floor(doublea) 返回最大的（最接近正无穷大）double值，该值小于或等于参数，并且等于某个整数log(doublea) 返回（底数是e）double值的自然对数 max(inta,intb) 返回两个int值中较大的一个 max(longa,longb) 返回两个long值中较大的一个 max(floata,floatb) 返回两个float值中较大的一个 max(doublea,doubleb) 返回两个double值中较大的一个 min(inta,intb) 返回两个int值中较小的一个 min(longa,longb) 返回两个long值中较小的一个 min(floata,floatb)
JAVA中常用类的常用方法 一、类 1、clone()方法 创建并返回此对象的一个副本。要进行“ 克隆” 的对象所属的类必须实现. Cloneable接口。 2、equals(Object obj)方法 功能：比较引用类型数据的等价性。 等价标准：引用类型比较引用，基本类型比较值。 存在特例：对File、String、Date及封装类等类型来说，是比较类型及对象的内 容而不考虑引用的是否为同一实例。 3、finalize()方法 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 4、hashCode()方法 返回该对象的哈希码值。 5、notify()方法 唤醒在此对象监视器上等待的单个线程。 6、notifyAll()方法 唤醒在此对象监视器上等待的所有线程。 7、toString()方法 返回该对象的字符串表示。在进行String与其它类型数据的连接操作时，自动调用toString()方法。可以根据需要重写toString()方法。 8、wait()方法 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。 二、字符串相关类 String类 charAt(int index) 返回指定索引处的 char 值。 compareTo(String anotherString) 按字典顺序比较两个字符串。 compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。 concat(String str) 将指定字符串连接到此字符串的结尾。 endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 equals(Object anObject) 将此字符串与指定的对象比较。 equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比 较，不考虑大小写。 indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。 lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 length() 返回此字符串的长度。 replace(char oldChar, char newChar)
JAVA屮常用类的常用方法 一．java?丨ang.Object 类 1、clone()方法 创建丼返M此对象的一个副木。要进行“克隆”的对象所属的类必须实现https://www.doczj.com/doc/5915927741.html,ng. Cloneable 接口。 2、equals(Objectobj)方法 0 功能：比较引用类型数据的等价性。 0 等价标准.?引用类型比较引用，基木类型比较值。 0 存在特例.?对File、String、Date及封装类等类型来说，是比较类型及对象的内稃而+ 考虑引用的是否为同一实例。 3、finalize〇方法 当垃圾丨"丨收器确定>(、存在对该对象的更多引用时，由对象的垃圾丨"丨收器调用此方法。 4、hashCode〇方法返 回该对象的哈希码值。 5、notify〇方法 唤醒在此对象监视器上等待的中?个线祝。 6、notifyAII〇方法 唤醒在此对象监视器上等待的所有线程= 7、toString()方法 返W该对象的字符串表示。在进行String与其它类型数据的连接操作时，&动调用tostringo 方法。可以根据耑要重写toStringO方法。 8、wait()方法 在其他线程调用此对象的n〇tify()方法或notifyAIIO方法前，异致当前线程等待。 二、字符串相关类 I String 类 charAt(int index)返回指定索引处的char值。compareTo{String anotherString)按字
典顺序比较两个字符串。compareTolgnoreCase(Stringstr)按字典顺序比较两个字 符串，不考虑人小写。concat(String str)将指定字符串连接到此字符串的结尾。 endsWith(String suffix)测试此字符串是否以指定的〗?缀结束。equals{Object anObject)将此字符串与指定的对象比较。 equalslgnoreCase(String anotherString)将此String 与另一个String 比较，考虑人小'与’。indexOf(int ch)返H指定字符在此字符串屮第一次出现处的索引。 indexOf(String str)返回第一次出现的指定子字符串在此字符串屮的索引， lastlndexOf(intch)返回指定字符在此字符串中最后??次出现处的索引。 length()返|n丨此字符串的长度。 replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用newChar替换此字符串中出现的所有oldChar得到的。 split(String regex)根据给定正则表达式的匹配拆分此字符串。startsWith{String prefix)测试此字符 串是否以指定的前缀开始。substring(int beginlndex) 返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。 substring(int beginlndex, int endlndex) 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的beginlndex 处开始，一直到索引endlndex-1处的字符。 t〇CharArray()将此字符串转换为一个新的字符数组。
JAVA中常用类的常用方法 一、https://www.doczj.com/doc/5915927741.html,ng.Object类 1、clone()方法 创建并返回此对象的一个副本。要进行“克隆”的对象所属的类必须实现https://www.doczj.com/doc/5915927741.html,ng. Cloneable接口。 2、equals(Object obj)方法 ?功能：比较引用类型数据的等价性。 ?等价标准：引用类型比较引用，基本类型比较值。 ?存在特例：对、Date及封装类等类型来说，是比较类型及对象的内容而不考虑引用的是否为同一实例。 3、finalize()方法 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 4、hashCode()方法返回该对象的哈希码值。 5、notify()方法唤醒在此对象监视器上等待的单个线程。 6、notifyAll()方法唤醒在此对象监视器上等待的所有线程。 7、toString()方法 返回该对象的字符串表示。在进行String与其它类型数据的连接操作时，自动调用toString()方法。可以根据需要重写toString()方法。 8、wait()方法 在其他线程调用此对象的notify() 方法或notifyAll() 方法前，导致当前线程等待。 二、字符串相关类 l String类 charAt(int index) 返回指定索引处的char 值。 compareTo(String anotherString) 按字典顺序比较两个字符串。 compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。 concat(String str) 将指定字符串连接到此字符串的结尾。 endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 equals(Object anObject) 将此字符串与指定的对象比较。 equalsIgnoreCase(String anotherString) 将此String 与另一个String 比较，不考虑大小写。indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。 lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 length() 返回此字符串的长度。 replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用newChar 替换此字符串中出现的所有oldChar 得到的。split(String regex) 根据给定正则表达式的匹配拆分此字符串。 startsWith(String prefix) 测试此字符串是否以指定的前缀开始。 substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。 substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的beginIndex 处开
java之public class和class声明区别详解（转） 在编写类的时候可以使用两种方式定义类： public class定义类: class定义类: 如果一个类声明的时候使用了public class进行了声明，则类名称必须与文件名称完全一致。 范例：定义一个类(文件名称为：Hello.java) public class HelloDemo{ //声明一个类，类名称的命名规范：所有单词的首字母大写public static void main(String args[]){ //主方法 System.out.println("Hello World!!!"); //系统输出，在屏幕上打印 } }; 此类使用public class声明，类名称是Hello Demo，但是文件名称Hello.java，所以，此时编译时会出现如下问题: Hello.java:1 类HelloDemo 是公共的，应在名为HelloDemo.java文件中声明 public class HelloDemo{ //声明一个类，类名称的命名规范：所有单词首字母大写 1、错误 以上的错误提示表示：因为使用的是public class声明，所以类名称应该与文件名称完全一致，即应该使用"HelloDemo.java"表示类的名称。 如果类的声明使用了class的话，则类名称可以与文件名称不一致，但是执行的时候肯定执行的是生成后的名称。 范例：有如下代码(文件名称为:Hello.java) class HelloDemo{ public static void main(String args[]){ System.out.println("Hello World!!!"); } }; 文件名称为Hello.java，文件名称与类名称不一致，但是因为使用了class声明所以，此时编译不会产生任何错误，但是生成之后的*.class文件的名称是和class声明的类名称完全一
一填空题 1)数组的元素通过数组下标来访问，数组Array的长度为元素的个数 （Array.length）。 2)Java中数组的下标的数据类型是整形。 3)不用下标变量就可以访问数组的方法是数组名。 4)数组最小的下标是0 。 5)arraycopy()的最后一个参数指明复制元素的个数。 6)向方法传递数组参数时，传递的是数组的引用。 7)数组初始化包括数组的声明，创建，初始化。 8)数组下标访问超出索引范围时抛出数组越界异常 9)浮点型数组的默认值是0.0f 。 10)对象型数组的默认值是null 。 二选择题 1.下面错误的初始化语句是_A B D__ A. char str[]="hello"; B. char str[100]="hello"; C. char str[]={'h','e','l','l','o'}; D. char str[]={'hello'}; 2.定义了一维int型数组a[10]后，下面错误的引用是_B_ A. a[0]=1; B. a[10]=2; C. a[0]=5*2; D. a[1]=a[2]*a[0]; 3.下面的二维数组初始化语句中，正确的是__B__ A. float b[2][2]={0.1,0.2,0.3,0.4}; B. int a[][]={{1,2},{3,4}}; C. int a[2][]= {{1,2},{3,4}}; D. float a[2][2]={0}; 4.引用数组元素时，数组下标可以是__D__ A. 整型常量 B. 整型变量 C. 整型表达式 D. 以上均可 5.定义了int型二维数组a[6][7]后，数组元素a[3][4]前的数组元素个数为__C__ A. 24 B. 25 C. 18 D. 17 6.下列初始化字符数组的语句中，正确的是_B___ A. char str[5]="hello"; B. char str[]={'h','e','l','l','o','\0'}; C. char str[5]={"hi"}; D. char str[100]=""; 7.数组在Java中储存在 C 中 A. 栈 B. 队列 C. 堆 D. 链表
例如求平方根的Math.sqrt(n)，求a的b次方Math.pow(a, b)，求绝对值Math.abs(n)等很多。下面是一些演示。 public class MathTest { public static void main(String[] args) { int n = 16; System.out.println(Math.sqrt(n)); System.out.println(Math.pow(2, 3)); System.out.println(Math.abs(-4)); System.out.println(Math.log10(100)); } } public class MathDemo { public static void main(String args[]){ /** * abs求绝对值 */ System.out.println(Math.abs(-10.4)); //10.4 System.out.println(Math.abs(10.1)); //10.1 /** * ceil天花板的意思，就是返回大的值，注意一些特殊值 */ System.out.println(Math.ceil(-10.1)); //-10.0 System.out.println(Math.ceil(10.7)); //11.0 System.out.println(Math.ceil(-0.7)); //-0.0 System.out.println(Math.ceil(0.0)); //0.0 System.out.println(Math.ceil(-0.0)); //-0.0 /** * floor地板的意思，就是返回小的值 */ System.out.println(Math.floor(-10.1)); //-11.0 System.out.println(Math.floor(10.7)); //10.0 System.out.println(Math.floor(-0.7)); //-1.0
5.2.1 编程实验1：基本类定义 本实验要求在封闭实验课中在教师指导下完成。 1. 实验目的 本实验旨在巩固学生对《Java语言程序设计》中第5章内容的掌握。在这个实验中学生将练习： ? 基本类的定义。 ? 使用自定义的基本类创建对象，并进行调用。 在强化练习中，学生将练习： ? 给基本类中增加属性 ? 在测试类中将增加的属性向控制台打印输出 2. 问题描述 编写一个类，描述学生的学号、姓名、成绩。学号用整型，成绩用浮点型,姓名用String类型。 编写一个测试类，输入学生的学号和成绩，并显示该学号的学生姓名，以及成绩。 3. 示例输出 4. 程序模板 class Student{ /* 此处创建三个属性。 */ } public class T1_Student{ public static void main(String[] args){ /* 先构造Student对象，然后分别为对象的属性赋值 最后打印输出对象的各个属性。 */ } } 5. 解答提示 1）在基本类的定义中描述学生类，学生的学号、成绩和姓名作为学生类的属性来描述。2）在测试类中写main方法，作为程序的入口进行运行，在main方法中创建学生对象，并
给对象的各个属性赋予具体值。 3）在测试类中用System.out.println()方法将属性的具体值输出到控制台，完成程序的输出结果要求。 6. 强化练习 1）给学生类添加性别属性，取值为boolean类型，用true表示男，用false表示女。 2）在测试类中输出学生的姓名、学号、成绩的同时，输出性别为：男或女。 5.2.2 编程实验2：构造方法 本实验要求在封闭实验课中在教师指导下完成。 1. 实验目的 本实验旨在巩固学生对《Java语言程序设计》中第5章内容的掌握。在这个实验中学生将练习： ? 定义多个基本类 ? 构造方法的定义 ? 构造方法的重载 在强化练习中，学生将练习： ? 构造方法的多个重载 ? 只通过指定长和宽来定制桌子。 2. 问题描述 编写一个类，描述桌子，包括以下几种属性：长、宽、高、颜色。并且使该类具有这样的功能：在定制桌子（即创建桌子对象时），就可以同时指定桌子的长宽高来订制。也可以同时指定长、宽、高、颜色来订制，也可单独指定桌子颜色来订制。 并编写一个测试类测试这几种定制方法。 5.2.3 编程实验3：访问器方法 本实验要求在封闭实验课中在教师指导下完成。 1. 实验目的 本实验旨在巩固学生对《Java语言程序设计》中第5章内容的掌握。在这个实验中学生将练习： ? 编写基本类，包括私有属性 ? 给基本类添加访问器方法，从而限制属性的读、写。 ? 测试类的编写，测试访问器方法对属性的读、写限制。 在强化练习中，学生将练习： ? 在基本类中添加私有属性。 ? 给该私有属性分别添加get和set访问器方法进行读、写。 2. 问题描述 编写一个类，描述银行账户，包括收入、支出和账户余额三种属性，同时包括对这三种
1 数组的概念 和其他语言一样，Java也提供数组支持，数组是属于引用类型，即数组是一个 对象。 强调数组的类型是引用类型。 数组的基本概念及作用 数组是相同数据类型元素的集合 数组本身是引用数据类型，即对象。但是数组可以存储基本数据类型，也可以存储引用数据类型。 数组的举例 int [] a = new int []{1,2,3,4,5}; String [] s = new String []{"小熊","小小熊","小小小熊"}; Employee [] e=new Employee[10];（Employee是自定义类） 2 数组的声明 数组的声明的两种方式： 数据类型 [] 数组名字例如：int [] a; 数据类型数组的名字 [] 例如： int a []; 注意： 在Java语言中两种声明方法没有任何区别，但是建议大家用第一种，避免混淆a的数据类型。 数组在声明后还只是一个空指针，不能使用，要想使用必须创建。 数组创建的三种方式：
?//声明数组的同时，根据指定的长度分配内存，但数组中元素值都为默认的初始化值 char[] chAry = new char[10]; ?//声明数组并分配内存，同时将其初始化 ?int[] ary1 = new int[]{1, 2, 3, 4, 5}; ?//与前一种方式相同，仅仅只是语法相对简略 ?int[] ary2 = {1, 2, 3, 4, 5}; 从另一个角度，数组创建可以分为动态和静态两种 动态创建数组（没有为元素赋值，可以结合for循环进行赋值） char[] chAry = new char[10]; 静态创建数组，在创建的时候，即为每个元素赋初值 int[] ary1 = new int[]{1, 2, 3, 4, 5}; 数组的长度 数组的长度：length属性 int [] b1 = new int []{1,2,3,4,5,6,7}; System.out.println(b1.length); 注意：数组的长度是属性，String的长度是length（）； 创建数组的时候必须指定数组的长度，而且一经定义则不允许改变。 数组的长度虽然是7，但是在内存中实际给8个位置，另外一个存储7. 数组之间赋值 在C语言中，不可以将数组直接赋值给另一个数组；
java中常用的一些方法 字符串 1、获取字符串的长度 length() 2 、判断字符串的前缀或后缀与已知字符串是否相同 前缀startsWith(String s) 后缀endsWith(String s) 3、比较两个字符串 equals(String s) 4、把字符串转化为相应的数值 int型Integer.parseInt(字符串) long型Long.parseLong(字符串) float型Folat.valueOf(字符串).floatValue() double型Double.valueOf(字符串).doubleValue() 4、将数值转化为字符串 valueOf(数值) 5、字符串检索 indexOf(Srting s) 从头开始检索 indexOf(String s ,int startpoint) 从startpoint处开始检索 如果没有检索到，将返回-1 6、得到字符串的子字符串 substring(int startpoint) 从startpoint处开始获取 substring(int start,int end) 从start到end中间的字符 7、替换字符串中的字符,去掉字符串前后空格 replace(char old,char new) 用new替换old trim() 8、分析字符串 StringTokenizer(String s) 构造一个分析器，使用默认分隔字符（空格，换行，回车，Tab，进纸符）StringTokenizer(String s,String delim) delim是自己定义的分隔符
nextToken() 逐个获取字符串中的语言符号 boolean hasMoreTokens() 只要字符串还有语言符号将返回true，否则返回false countTokens() 得到一共有多少个语言符号 文本框和文本区 1、文本框 TextField() 构造文本框，一个字符长 TextField(int x) 构造文本框，x个字符长 TextField(String s) 构造文本框，显示s setText(String s) 设置文本为s getText() 获取文本 setEchoChar(char c) 设置显示字符为c setEditable(boolean) 设置文本框是否可以被修改 addActionListener() 添加监视器 removeActionListener() 移去监视器 2、文本区 TextArea() 构造文本区 TextArea(String s) 构造文本区，显示s TextArea(String s,int x,int y) 构造文本区，x行，y列，显示s TextArea(int x,int y) 构造文本区，x行，y列 TextArea(String s,int x,ing y,int scrollbar) scrollbar的值是： TextArea.SCROLLBARS_BOTH TextArea.SCROLLBARS_VERTICAL_ONLY TextArea.SCROLLBARS_HORIZONTAL_ONLY TextArea.SCROLLBARS_NONE setText(String s) 设置文本为s
试验四 类和对象的创建 一.类的定义 类是组成Java程序的基本要素。类封装了一类对象的状态和方法。类用来定义对象的模板。 类的实现包括两部分：类声明和类体。基本格式为： 修饰符class类名[extends父类名]{ /*类体的内容*/ } 1.类声明 以下是一个类声明的例子。 class People成为类声明，People是类名。习惯上，类名的第一个字母大写，但这不是必须的。类的名字不能是Java中的关键字，要符合标识符规定，即类的名字可以由字母、下划线、数字或美元符号组成，并且第一个字母不能是数字。但给类命名时，最好遵守下列规则： (1)如果类名使用拉丁字母，那么名字的首写字母使用大写字母，如Hello、Time、People等。 (2)类名最好容易识别，当类名由几个“单词”复合而成时，每个单词的首写字母使用大写，如BeijingTi me、AmericanGame、HelloChina等。 2.类体 编写类的目的是为了描述一类事物共有的属性和功能，描述过程由类体来实现。类声明之后的一对大括号“{”、“}”以及它们之间的内容称为类体，大括号之间的内容称为类体的内容。 类体的内容由两部分构成：一部分是变量的定义，用来刻画属性；另一部分是方法的定义，用来刻画功能。 下面是一个类名为“Trapezia”的类，类体内容的变量定义部分定义了4个float类型变量：top、bottom、h igh和laderArea，方法定义部分定义了两个方法：“getArea”和“setHigh”。
二.对象 1.对象的创建 创建一个对象包括对象的声明和为对象分配内存两个步骤。 (1)对象的声明。 一般格式为： 类的名字对象名字; 如： 这里People是类的名字，zhubajie是我们声明的对象的名字。 (2)为声明的对象分配内存。 使用new运算符和类的构造方法为声明的对象分配内存，如果类中没有构造方法，系统会调用默认的构造方法（你一定还记得构造方法的名字必须和类名相同这一规定），如： 例1： 「注」如果类里定义了一个或多个构造方法，那么Java不提供默认的构造方法。 2.对象的使用 对象不仅可以改变自己变量的状态，而且还拥有了使用创建它的那个类中的方法的能力，对象通过使用这些方法可以产生一定的行为。 通过使用运算符“.”，对象可以实现对自己的变量访问和方法的调用。 例2：
若想要存放一连串相同数据类型的数据，使用数组是个相当好用的选择。此外，如果某个程序片段经常反复出现，那么将它定义成一个方法可以有效地简化程序代码。本章主要是介绍数组的基本用法与方法的应用，学完本章，将会对数组与方法的使用有更深一层的认识。 数组是由一组相同类型的变量所组成的数据类型，它属于引用类型。它们以一个共同的名称表示，数组中的每个元素则以下标来访问。数组依照存放元素的复杂程度分为一维数组、二维和多维数组，先来看看一维数组。 3.1 一维数组 一维数组可以存放上千万个数据，并且这些数据的类型是完全相同的。可以将它简单的理解为是相同数据类型的数据的集合。 3.1.1 一维数组的声明与内存的分配 要使用Java的数组，必须经过两个步骤： （1）声明数组 （2）给数组分配内存 这两个步骤的语法如下： 数据类型数组名[ ]; 或数据类型[ ] 数组名; // 声明一维数组 数组名= new 数据类型[个数]; // 给数组分配内存 数组的声明格式里，“数据类型”是声明数组每个元素的数据类型，常见的类型有整型、浮点型与字符型等，也可以是引用类型。“数组名”是用来统一这组相同数据类型的元素的名称，其命名规则和变量的相同，建议使用有意义的名称为数组命名。数组声明后，接下来便是要配置数组所需的内存，其中“个数”是告诉编译器，所声明的数组要存放多少个元素，而“new”则是命令编译器根据括号里的个数，在内存中开辟一块内存供该数组使用。 需要注意的是，在Java中声明数组的时候，不能在[]中指定其长度。比如：int score[3]; // 错误 下面是关于一维数组的声明并分配内存给该数组的一个范例： int score[]; // 声明整型数组score score = new int[3]; // 为整型数组score分配内存空间，其元素个数为3 在上例中的第一行，当声明一个整型数组score时，score可视为数组类型的变量，此时这个变量并没有包含任何内容，编译器仅会分配一块内存给它，用来保存指向数组实体的地址，如图3-1所示。 图3-1 声明整型数组 声明之后，接着要做内存分配的操作，也就是上例中第二行语句。这一行会开辟3个可供保存整数的内存空间，并把此内存空间的参考地址赋给score变量。其内存分配的流程如图3-2所示。
java常用类知识点总结 Java常用类 要求: 1、掌握String和StringBuffer的区别，可以熟练使用String和StringBuffer的各 种方法进行相关操作。 2、能够自己编写一个得到日期的操作类，并将日期进行格式化操作。 3、掌握比较器及其基本原理，并可以通过比较器进行对象数组的比较操作。 4、掌握对象克隆技术及其实现 5、能够灵活应用正则表达式对字符串的组成进行判断 6、掌握Math、Random、基本数据类型的包装类的使用 7、描述出Object System对垃圾收集的支持 8、使用NumberFormat、DecimalFormat、BigInteger、BigDecimal进行数字的操 作 String和StringBuffer String的内容一旦声明不可改变，如果要改变，改变的是String的引用地址，如果一个字符串要经常改变，必须使用StringBuffer。 在一个字符串内容需要频繁修改时，使用StringBuffer可以提升操作性能，因为StringBuffer内容可以改变，而String内容不可改变。StringBuffer支持的方法大部分与String类似。 StringBuffer常见用法: (1) 字符串的连接操作
String类可以通过“+“进行字符串的连接，而StringBuffer中却只能使用append方法进行字符串的连接，而且此方法返回一个StringBuffer类的实例，这样就可以采用代码链的形式一直调用append方法。 (2) 在任意位置处为StringBuffer添加内容 可以使用insert方法在指定位置上为StringBuffer添加内容 字符串的反转操作(较为常见的操作，使用reverse方法) (3) 替换指定范围的内容 replace方法可对指定范围的内容进行替换。在String中如果要替换，使用的是replaceAll (4) 字符串截取(使用subString方法从指定范围中截取内容) (5) 删除指定范围的字符串(使用delete方法删除指定范围内容) (6) 查找指定内容是否存在(indexOf查找指定内容，查找到返回内容的位置， 没查到返回-1) 问题:(1)String s = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有, 没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。在这段代码中，s原先指向一个String对象，内容是 "Hello"，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢,答案是没有。这时，s不指向原来那个对象了，而指向了另一个 String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改， 或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变，所以对于每一个不同的字符
1.知识点 一维数组：定义、初始化、使用（相关的算法，常用系统类的使用） 多维数组：定义、初始化、使用 增强for循环，break、continue控制语句的学习 2.讲解 什么是数组？ 例子 //要求把一个班的一门课的成绩，加起来求平均值； import java.util.*; class Average{ public static void main(String[] args){ Scanner sc = new Scanner(System.in); float avg=0; float sum=0; int count=1; while(count<=3){ sum=sum+sc.nextFloat(); count++; } avg=sum/(count-1); System.out.println("平均值是:"+avg); System.out.println("程序结束"); } } //新要求：我要在输出平均值的同时，也要将这门课的最高分，最低分，同时也要能看到这门的成绩 数组概念：一组能够存储相同数据类型值的变量的集合。 在java中我们本着一切是对象的原则，我们把数组在java中看成是对象，数组对象。数组是最基本的引用型数据类型。 一维数组的知识点 定义方法： 1、三步法 A、int[] arr;用来申明数组的引用，在栈中为arr开辟内存； B、arr = new int[5];这是为数组arr在堆中为数组元素开辟6个存储单元； C、把数组在堆中的起始位置给了arr这个引用变量 *一般我们的程序在运行时，我们为局部变量在栈中开辟内存，而为对象(对象属性)在堆中开辟内存。为对象方法在方法区开辟内存空间。为类的属性，在静态区开辟内存空间。 具体的内存图：
Java中数组的声明 一维数组的声明： 在Java中，数组是独立的对象，有自身的方法，不是变量的集合。 数组的声明： 类型标识符数组名[ ] 或者类型标识符[] 数组名。 数组的长度是在创建的时候决定的。 数组的创建方法： 先声明后创建： int array[]; array = new int[10]; 在声明的同时创建： int array[] = new int[10]; 直接赋值： int array[]= new int[1,2,3,4]; 数组下标从0开始。 数组是引用类型，他的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐士地初始化。如： public class Testpublic static void main(Stirng [] args)?? int [] a = new int [5]; ?? Date[] days=new Date[3]; ?? System.out.println(a[3]); ?? System.out.println(days[2]);} class Dateint year,month,day; Date(int year,int month,int day)?? this.year=year; ?? this.month=month; ?? this.day=day;} 结果将是：0????? null 数组的拷贝 最有效率的方法是使用https://www.doczj.com/doc/5915927741.html,ng.System类的静态方法： public static void arraycopy(object src,int srcPos,object dest, ???????????????? int destPos,int length) 可以用于数组src从第srcPos项元素开始的length个元素拷贝到目标数组从destPos项开始的length个位置。 如果源数据数目超过目标数组的边界，系统就会抛出异常。 二维数组 float[][] numthree;???????????? //定义一个float类型的2维数组 numthree=new float[5][5];?????? //为它分配5行5列的空间大小 numthree[0][0]=1.1f;??????????? //通过下标索引去访问???? 1行1列= 1.1 numthree[1][0]=1.2f;????????????????????????????????? // 2行1列=1.2 numthree[2][0]=1.3f;????????????????????????????????? // 3行1列=1.3 numthree[3][0]=1.4f;????????????????????????????????? // 4行1列=1.4
面向对象编程 本篇简单介绍面向对象的三个特性，这些特性会在后续中详细讲解。 1、面向对象的三个特性 （1）封装 面向对象的编程核心思想之一就是将数据和对数据的操作封装在一起，从实例中抽取共同性质形成一个概念。 （2）继承 继承体现了一种先进的编程模式，子类可以继承父类的属性和功能，即继承了父类所具有的数据和操作，同时子类还可以增加独有的数据和操作。比如，”猫“继承了“动物类…的属性和功能，但是它又有自己独特的属性和功能，猫可以”喵喵“的叫。 （3）多态 多态是面向对象编程的又一重要特征。多态有两种意义，一种是操作名称的多态，一种是与继承有关的多态，同一种操作被不同的类型对象调用产生不同的行为，比如猫和狗都有动物的叫功能，但是猫的叫声为”喵喵“，狗的叫声为”汪汪“，这就是多态。 2、Java类的声明 类是组成java程序的基本要素，在类里封装了一类对象的状态和方法。同时类也是规范对象的模板，可以创建对象。 类的定义格式： class 类名{ 类体的内容 } class是关键字，用来定义类。”class 类名“是类的声明部分，类名必须是合法的Java标识符。如： class Dog{ int i ; …… } 3、成员变量 （1）成员变量在使用时可以是任何一种数据类型类型（包括基本类型和引用类型）。（2）在定义成员变量时可以对其初始化，如果不对其初始化，java使用默认的对其初始化（详见下图）。 （3）成员变量的作用范围为整个类体。
4、方法 类体的内容有两个：成员变量和方法，其中，一部分方法称为构造方法，供类创建对象时使用，用来给出类所创建的对象初始状态。另一部分方法可分为实例方法和类方法。类所创建的对象可以调用这些方法形成一定的算法，体现对象具有的某种功能。 方法的定义：方法声明和方法体。其一般格式为： 方法声明部分{ 方法体内容 } 最基本的方法声明包括方法名和方法的返回类型，返回类型也称为方法的类型，如：int area（）{ ……} 该方法的名字为area，类型为int 方法返回的数据类型可以是任意java 数据类型，当方法不需要返回数据时，返回类型必须是void 。如：void Dog（）{……}。 5、方法重载 谈到方法不得不说方法的重载，方法重载是多态性的一种，所谓多态性，是指可以向功能传递不同的消息，以便让对象相应的消息来产生一定的行为。对象的功能是通过类中的方法来体现，那么功能的多态性就是方法的重载。 方法重载是指一个类中可以有多个方法具有相同的名字，但方法的参数必须不同，如果两个方法的名字相同，即使类型不同，也必须保证参数不同。另一种多态是与继承有关的多态，将在继承讨论。 方法的重载例如： [java]view plaincopyprint? 1class Fang{ 2double getArea(double x,int y){ 3return x*y; 4 } 5int getArea(int x,double y){ 6return (int)(x*y);
学号 Java语言程序设计C 实验报告 实验2 数组及常用算法 学生姓名 专业、班级 指导教师 成绩 计算机与信息工程学院 年月日
一、实验目的 学习课程相关章节知识，通过上机练习，掌握以下知识： 1．掌握Java中对象和引用变量的概念 2．掌握Java数组的使用和本质 3．掌握数组相关常用算法（复制及排序方法） 二、实验内容 写一个方法，功能：定义一个一维的int 数组，长度为10，把从控制台输入整数赋值给数组,然后将它们按从小到大的顺序输出（使用冒泡排序）（知识点：数组遍历、数组元素访问） 三、实验思想 1．Java中对象和引用变量的概念 2．Java数组的使用和本质 3．数组相关常用算法（复制及排序方法） 四、实验结果 package sss; import java.util.Scanner; public class aaa { public static void main(String[] args) { // TODO自动生成的方法存根 Scanner input=new Scanner(System.in); System.out.println("排序之前的数组："); int a[]=new int[10]; for(int b=0;b