我是靠谱客的博主 畅快便当，最近开发中收集的这篇文章主要介绍23 eclipse、数组、排序和查找算法第一个IDE——eclipseeclipse的常见配置数组作业题排序和查找算法Arrays类的学习和使用，觉得挺不错的，现在分享给大家，希望可以做个参考。
概述
目录标题
- 第一个IDE——eclipse
- eclipse的常见配置
- 数组
- 数组的定义
- Java如何定义数组
- 数组的遍历
- 课堂案例
- 二维数组
- 定义格式
- 作业题
- 第一题
- 第二题
- 第三题
- 第四题
- 第五题
- 第六题
- 第七题
- 排序和查找算法
- 冒泡
- 大数上浮法
- 小数下沉法
- 选择
- 插入
- 二分查找（折半查找）
- Arrays类的学习和使用
- 拷贝
第一个IDE——eclipse
下载地址：https://www.eclipse.org/downloads/
- 下载步骤
解压到对应文件夹
进入eclipse.ini文件
在最后一行添加代码
-Dfile.encoding=UTF-8
双击打开eclipse—给代码选择一个文件夹存储
其他正常操作就可以了
eclipse的常见配置
- 快捷键
1CTRL+/:注释代码（单行注释）取消同样
2 alt+/:代码提示
3 ctrl+shift+/:多行注释，取消是ctrl+shift+
4 ctrl+alt+上下键:向上向下粘贴
5 ctrl+d:删除
6 alt+上下键：代码的上下移动
7 也可以自己定义快捷键
8 可以自己设置输入什么字母给代码提示，默认是.给代码提示
9 ctrl+a:全选
10 ctrl+shift+f:格式化
11 ctrl +1:代码错误提示
数组
当编程中遇到了大量数据的时候，使用传统的变量定义来保存数据，已经不现实了，所以用容器来解决问题（数组、栈、链表…)
数组的定义
数组是一种比较特殊的容器，因为数组的定义是：数组是一种连续的内存空间的分配
Java如何定义数组
1 数据类型[ ] 变量名称 = new 数据类型[ 大小 ]
package com.openlab.dyq.array;
import javax.xml.transform.TransformerException;
public class Testarray {
public static void main(String[] args) {
int[] arr = new int[10];//定义了一个大小为10的数组
//如何访问数组的元素，使用下标（0~（最大长度-1））
arr[0] = 52;
arr[2] = 5;
arr[5] = 55;
arr[4] = 152;
System.out.println(arr[0]);
System.out.println(arr[2]);
System.out.println(arr[5]);
System.out.println(arr[4]);
//数组下标如果超出数组长度-1，则会抛出数组下标越界异常
//arr[12] = 5;
//System.out.println(arr[12]);
//怎么获取数组的元素个数
System.out.println(arr.length);
System.out.println(arr[(arr.length-1)]);
}
}
2 在定义的同时，将元素的值也初始化了
数据类型 [ ] 变量名称=new 数据类型 [ ] {元素1，元素2…}
package com.openlab.dyq.array;
public class TestArray02 {
public static void main(String[] args) {
//第二种定义数组的方式
String [] names = new String[] {"张三","李四","王五"};
System.out.println(names[1]);
names[0] = "鬼";
System.out.println(names[0]);
//第三种方法
double[]prices = {6.56,8.2,5,6.2};
System.out.println(prices[2]);
}
}
包（package)可以理解为文件夹，Java要求一个项目通过分包的方式来管理项目
分包的好处 1 有利于代码的管理和维护以及开发2 防止名称的冲突
包名称的行业规范：
公司域名倒着写.项目名称.功能模块的名称
com.baidu.cms.db
数组的遍历
package com.openlab.dyq.array;
public class TestArray02 {
public static void main(String[] args) {
//第二种定义数组的方式
String [] names = new String[] {"张三","李四","王五"};
System.out.println(names[1]);
names[0] = "鬼";
System.out.println(names[0]);
//第三种方法
double[]prices = {6.56,8.2,5,6.2};
//System.out.println(prices[2]);
for(int i=0;i<prices.length;i++) {
prices[i] +=10;
System.out.println(prices[i]);
}
//for循环加强 foreach for in
for (double p:prices) {
System.out.println(p);
}
}
}
课堂案例
请输入10位同学的Java成绩
1 求平均成绩，最高成绩，最低成绩
2 对10位同学的成绩按照从低到高的顺序排列
package com.openlab.dyq.array;
import java.util.Scanner;
public class TestArray03 {
public static void main(String[] args) {
double[] scores = new double[10];
double sum = 0,max = 0,min = 0;
Scanner sc = new Scanner(System.in);
for (int i = 0; i < scores.length; i++) {
System.out.print("请输入第"+(i+1)+"个同学的成绩：");
scores[i] = sc.nextDouble();
sum += scores[i];
if(i==0) {
max = scores[i];
min = scores[i];
}else {
if(max < scores[i]) {
max = scores[i];
}
if(min > scores[i]) {
min = scores[i];
}
}
}
//不在使用的时候，关闭Scanner对象
sc.close();
System.out.println("平均成绩："+(sum/scores.length));
System.out.println("最高成绩："+max);
System.out.println("最低成绩："+min);
}
}
请输入第1个同学的成绩：98
请输入第2个同学的成绩：86
请输入第3个同学的成绩：69
请输入第4个同学的成绩：98
请输入第5个同学的成绩：90
请输入第6个同学的成绩：86
请输入第7个同学的成绩：58
请输入第8个同学的成绩：99
请输入第9个同学的成绩：78
请输入第10个同学的成绩：59
平均成绩：82.1
最高成绩：99.0
最低成绩：58.0
之前讲的都是一维数组
二维数组
定义格式
数据类型[ ] [ ] 变量名称 = new 数据类型[行数] [列数] ;
package com.openlab.dyq.array;
import java.util.Scanner;
public class TestArray04 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[][] arr = new int[4][3];
for (int i=0;i<arr.length;i++) {
for(int j = 0;j<arr[i].length;j++) {
arr[i][j] = sc.nextInt();
}
}
for (int i=0;i<arr.length;i++) {
for(int j = 0;j<arr[i].length;j++) {
System.out.println(arr[i][j]);
}
}
}
}
package com.openlab.dyq.array;
public class TestArray05 {
public static void main(String[] args) {
int[][] a = {{1,2,3},{4,5,6},{7,8,9}};
for (int i=0;i<a.length;i++) {
for(int j = 0;j<a[i].length;j++) {
System.out.print(a[i][j]+" ");
}
System.out.print("n");
}
}
}
1 2 3
4 5 6
7 8 9
作业题
第一题
请输入10位同学的java成绩，1、求平均成绩，最高成绩、最低成绩？2、对10个成绩按照从低到高的顺序排列
package com.openlab.Array.hw;
import java.util.Scanner;
public class hw01 {
public static void main(String[] args) {
int arr[]=new int[10];
Scanner sc = new Scanner(System.in);
//输入成绩
int max=0,min=0,sum=0;
for(int i=0;i<=9;i++){
System.out.println("请输入第"+(i+1)+"个同学成绩：");
int number=sc.nextInt();
arr[i]=number;
sum+=arr[i];
//比较大小
if(i==0){
max=arr[i];
min=arr[i];
}else {
if(max<arr[i]){
max=arr[i];
}
if(min>arr[i]){
min=arr[i];
}
}
}
sc.close();
System.out.println("平均成绩："+(sum/arr.length));
System.out.println("最大值为："+max);
System.out.println("最小值为："+min);
}
}
请输入第1个同学成绩：
16
请输入第2个同学成绩：
56
请输入第3个同学成绩：
65
请输入第4个同学成绩：
32
请输入第5个同学成绩：
98
请输入第6个同学成绩：
65
请输入第7个同学成绩：
32
请输入第8个同学成绩：
69
请输入第9个同学成绩：
89
请输入第10个同学成绩：
99
平均成绩：62
最大值为：99
最小值为：16
排序
//import java.util.Scanner;
public class hw01 {
public static void main(String[] args) {
int arr[]=new int[]{12,20,80,96,54,32,50,64,32,60};
// Scanner sc = new Scanner(System.in);
// //输入成绩
// int max=0,min=0,sum=0;
// for(int i=0;i<=9;i++) {
// System.out.println("请输入第" + (i + 1) + "java同学成绩：");
// int number = sc.nextInt();
// arr[i] = number;
// }
int sort[] =bubble_sort(arr);
for(int i=0;i<sort.length-1;i++){
System.out.print(sort[i]+" ");
}
}
public static int[] bubble_sort(int arr[]){
//冒泡排序
for(int i =0;i<arr.length-1;i++){
//遍历次数
for(int j=0;j<arr.length-1-i;j++){
//获取下标比较，按升序排列
if(arr[j]>arr[j+1]){
int num=0;//存储交换值
//交换
num=arr[j];
arr[j]=arr[j+1];
arr[j+1]=num;
}
}
}
return arr;
}
}
12 20 32 32 50 54 60 64 80
第二题
给定一个数组，判断某个元素是否在该数组中
package com.openlab.Array.hw;
import java.util.Scanner;
public class hw02 {
public static void main(String[] args) {
Scanner sc =new Scanner(System.in);
int arr[] = new int[]{12, 20, 80, 96, 54, 32, 50, 64, 32, 60};
System.out.println("请输入元素：（数字)");
int val=sc.nextInt();
int tmp=judge(val,arr);
if(tmp==1){
System.out.println("存在");
}else {
System.out.println("不存在");
}
sc.close();
}
public static int judge(int val,int arr[]){
int tmp=0;
for(int i=0;i<arr.length;i++){
if (val==arr[i]){
tmp=1;
}
}
return tmp;
}
}
请输入元素：（数字)
32
存在
第三题
给定一个数组，大小为10，输入十个同学的成绩，求这些成绩的总分数，某一天转入2个新同学，请再次求12个同学的平均成绩（尝试着使用扩容的形式做）
package com.openlab.Array.hw;
public class hw03 {
public static void main(String[] args) {
int student[]=new int[]{13,25,6,575,82,42,4,5,1,10};
int sum=0;
student=add(student.length+2,student);
student[student.length-1]=100;
student[student.length-2]=100;
for(int i =0;i<student.length;i++){
sum+=student[i];
}
System.out.println("总分数为："+sum);
}
public static int[] add(int newlen,int arr[]){
int sort[] =new int[newlen];
for(int i =0;i<arr.length;i++){
sort[i]=arr[i];
}
return sort;
}
}
第四题
有一堆硬币，每次只能拿一个或者两个，求最少多少次可以拿完硬币{10, 8, 5, 3, 27, 99}
package com.openlab.Array.hw;
public class hw04 {
public static void main(String[] args) {
int [] arr={10,8,5,3,27,99};
System.out.println(getCoin(arr));
}
public static int getCoin(int [] arr) {
int count = 0;
for(int i=0;i < arr.length;i++) {
int num = arr[i];
if(num%2 ==0) {
count +=num/2;
}else {
count += num/2 +1;
}
}
return count;
}
}
78
第五题
将数组中的重复数据去重
去重的几种方法
package com.openlab.Array.hw;
public class hw05 {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5, 21, 1, 1, 2, 3, 4, 56, 7, 1, 23, 4 };
//去重
int[] uniArr = unique(arr);
for(int i:uniArr) {
System.out.println(i);
}
}
private static int[] unique(int[] arr) {
// 重新创建一个新的数组
int[] newArr = new int[arr.length];
int index = 0;
for(int i = 0;i < arr.length;i++) {
//判断每一个数组中的元素在不在新的数组中
if (!isExists(arr[i],newArr)) {
//不重复
newArr[index++] = arr[i];
}
}
return newArr;
}
//判断一个数，在不在数组中
private static boolean isExists(int num,int[]arr) {
for(int j:arr) {
if(j == num) {
return true;
}
}
return false;
}
}
1
2
3
4
5
21
56
7
23
0
0
0
0
0
0
0
第六题
如何将10个0-10随机存入数组中
package com.openlab.Array.hw;
import java.util.Random;
/**
* @program: HeiMa-com.itheima.code
* @description:
* @author: chenzhongjun
* @date: 2019-12-03 11:41
* @demand： 利用随机数生成10个范围 1-10的随机数存入数组
* （随机数不可以重复），并打印在控制台
*/
public class hw06 {
public static void main(String[] args) {
//定义数组
int[] arr = new int[10];
Random random = new Random();
//定义计数器
boolean b = false;
int count = 0;
//外层循环创建生成随机数
for (int i = 0; i < 100; i++) {
int temp = random.nextInt(10) + 1;
//内层循环比较随机数是否与数组数据相同
for (int j = 0; j < arr.length; j++) {
//如果不相同则使判断器为true
if (temp != arr[j]) {
b = true;
} else {//如果相同则使判断器为false,并结束循环
b = false;
break;
}
}
//判断是否能将随机数写入数组
while (b) {
//设定写入的上限为数组的长度
if (count == arr.length) {
break;
}
arr[count] = temp;
//成功写入后计数器增加，并将判断器改为false
count++;
b = false;
}
}
//遍历循环打印数组
for (int a : arr
) {
System.out.println(a);
}
}
}
6
10
3
1
5
7
8
2
9
4
public class hw06 {
public static void main(String[] args) {
int[] arr=new int[10];
for(int i=0;i<arr.length;i++){
arr[i]=(int)(Math.random()*10);
}
for(int i:arr) {
System.out.print(i+" ");
}
}
}
0 4 9 6 3 0 0 8 4 2
第七题
（选做题）
某个人进入如下一个棋盘中，要求从左上角开始走，
最后从右下角出来（要求只能前进，不能后退），
问题：共有多少种走法？
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
package com.openlab.code8.hw;
public class Leetcode62 {
public static void main(String[] args) {
// int[][] path = new int[10][20];
// System.out.println(path.length);//行
// System.out.println(path[0].length);//列
System.out.println(uniquePaths(6,9));
}
public static int uniquePaths(int m,int n) {
int[][]path = new int[m][n];
//第一行都设置为1
for(int i = 0;i < path.length;i++) {
path[i][0] = 1;
}
//第一行设置为1
for (int i = 0;i < path[0].length;i++) {
path[0][i] = 1;
}
for(int i = 1;i < path.length;i++) {
for(int j = 1;j < path[0].length;j++) {
path[i][j] = path[i-1][j] + path[i][j-1];
}
}
return path[m - 1][n - 1];
}
}
package com.openlab.Array.hw;
import java.util.Scanner;
public class hw07 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入行数：");
int x=sc.nextInt();
System.out.println("请输入列数：");
int y=sc.nextInt();
int count=run(x,y);
System.out.println("方法总共有"+count+"种");
sc.close();
}
public static int run(int x,int y){
int count=0;
while (x>0&&y>0){
if(x==1){
count++;
x=0;
}else if(y==1){
count++;
y=0;
}else {
count=run(x-1,y)+run(x,y-1);
break;
}
}
return count;
}
}
请输入行数：
6
请输入列数：
9
方法总共有1287种
棋盘进阶
package com.openlab.Array.hw;
public class Leetcode63 {
public static void main(String[] args) {
int[][] arr = {
{0,0,0,1,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,1,0,0},
{1,0,0,0,0,0,1,0},
{0,0,0,0,0,0,0,0},
};
int count = uniquePaths(arr);
System.out.println(count);
}
private static int uniquePaths(int[][] arr) {
if (arr[0][0] == 1) {
return 0;
}
//重新构建一个数组
int [] [] newArr = new int[arr.length] [arr[0].length];
for(int i = 0;i < arr.length;i++) {
if (arr[i][0] == 1 ) {
break;
}else {
newArr[i][0] = 1;
}
}
for(int i = 0;i < arr[0].length;i++) {
if (arr[0][i] == 1 ) {
break;
}else {
newArr[0][i] = 1;
}
}
for (int i = 1;i < newArr.length;i++) {
for(int j = 1;j < newArr[0].length;j++) {
if(arr[i][j] == 1) {
newArr[i][j] = 0;
}else {
newArr[i][j] = newArr[i-1][j] + newArr[i][j-1];
}
}
}
return newArr[arr.length - 1][arr[0].length - 1];
}
}
排序和查找算法
排序是程序中应用最多的一种算法
冒泡
两两比较，找到最大值或者最小值的方式
大数上浮法
package com.openlab.sort.cls;
public class Sort01 {
public static void main(String[] args) {
int [] arr = {1,2,9,-100,-55,23,-99,0,3,4,8};
bubbleSort(arr);
for (int i : arr) {
System.out.print(i+",");
}
}
//冒泡排序
private static void bubbleSort(int[] arr) {
//外层循环控制每一次找最大值找了多少次
for (int i = 0; i < arr.length-1; i++) {
//内层循环表示每次进去找那个最大值
for (int j = 0; j < arr.length-1-i; j++) {
if (arr[j] > arr[j+1]) {
swap(arr,j,j+1);
}
}
}
}
private static void swap(int[] arr, int d, int y) {
arr[d] = arr[d] + arr[y];
arr[y] = arr[d] - arr[y];
arr[d] = arr[d] - arr[y];
}
}
小数下沉法
package com.openlab.sort.cls;
public class Sort02 {
public static void main(String[] args) {
int [] arr = {1,2,9,-100,-55,23,-99,0,3,4,8};
bubbleSort(arr);
for (int i : arr) {
System.out.print(i+",");
}
}
//冒泡排序,基于小数下沉法
private static void bubbleSort(int[] arr) {
//外层循环控制每一次找到一个最小数
for (int i = 0; i < arr.length-1; i++) {
//内层循环表示每次进去找哪个最小值
//325
//325
//235
for (int j = arr.length - 1; j > i; j--) {
if (arr[j-1] > arr[j]) {
swap(arr,j-1,j);
}
}
}
}
private static void swap(int[] arr, int d, int y) {
arr[d] = arr[d] + arr[y];
arr[y] = arr[d] - arr[y];
arr[d] = arr[d] - arr[y];
}
}
选择
每次找到最小值，将它交换到对应的位置
package com.openlab.sort.cls;
public class Sort03 {
public static void main(String[] args) {
int [] arr = {1,2,9,-100,-55,23,-99,0,3,4,8};
SelectSort(arr);
for (int i : arr) {
System.out.print(i+",");
}
}
//选择排序
private static void SelectSort(int[] arr) {
for (int i = 0; i < arr.length-1; i++) {
int min = i;
for (int j = i; j < arr.length ; j++) {
if (arr[min] > arr[j]) {
min = j;
}
}
if (min != i) {
swap(arr,i,min);
}
}
}
private static void swap(int[] arr, int d, int y) {
arr[d] = arr[d] + arr[y];
arr[y] = arr[d] - arr[y];
arr[d] = arr[d] - arr[y];
}
}
package com.openlab.sort.cls;
public class Sort04 {
public static void main(String[] args) {
int [] arr = {1,2,9,-100,-55,23,-99,0,3,4,8};
SelectSort(arr);
for (int i : arr) {
System.out.print(i+",");
}
}
//选择排序的变种，也可以认为是选择结构
private static void SelectSort(int[] arr) {
for (int i = 0; i < arr.length-1; i++) {
for (int j = i; j < arr.length ; j++) {
if (arr[i] > arr[j]) {
swap(arr,i,j);
}
}
}
}
private static void swap(int[] arr, int d, int y) {
arr[d] = arr[d] + arr[y];
arr[y] = arr[d] - arr[y];
arr[d] = arr[d] - arr[y];
}
}
插入
默认数组第一个元素是有序的，从第二个开始，向有序进行插入
package com.openlab.sort.cls;
public class Sort05 {
public static void main(String[] args) {
int [] arr = {1,2,9,-100,-55,23,-99,0,3,4,8};
insertSort(arr);
for (int i : arr) {
System.out.print(i+",");
}
}
//插入排序
private static void insertSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
for (int j = i;j > 0 && arr[j] < arr[j-1];j--) {
swap(arr,j,j-1);
}
}
}
private static void swap(int[] arr, int d, int y) {
arr[d] = arr[d] + arr[y];
arr[y] = arr[d] - arr[y];
arr[d] = arr[d] - arr[y];
}
}
二分查找（折半查找）
如果查询数据是无序的，那就得线性（遍历）查找
package com.openlab.search.cls;
import com.openlab.sort.cls.Sort05;
public class search01 {
public static void main(String[] args) {
int [] arr = {1,2,9,-100,-55,23,-99,0,3,4,8};
//调用,必须是public，private不能被调用
Sort05.insertSort(arr);
int index = LinearSearch(arr,8);
System.out.println(index);
}
//线性查找，可以查询，但是效率较低
private static int LinearSearch(int[] arr, int key) {
for (int i = 0; i < arr.length; i++) {
if(key == arr[i]) {
return i;
}
}
return -1;
}
}
package com.openlab.search.cls;
import com.openlab.sort.cls.Sort05;
public class search02 {
public static void main(String[] args) {
int [] arr = {1,2,9,-100,-55,23,-99,0,3,4,8};
//调用,必须是public，private不能被调用
Sort05.insertSort(arr);
int index = binarySearch(arr,8);
System.out.println(index);
}
//二分查找,又叫做折半查找
private static int binarySearch(int[] arr, int key) {
int start = 0;
int end = arr.length - 1;
while (start <= end) {
//注意，需要将中间值的下标重新计算
int middle = (start + end)/2;
if(arr[middle] > key) {
end = middle - 1;
}else if (arr[middle] < key) {
start = middle + 1;
}else {
return middle;
}
}
return -1;
}
}
Arrays类的学习和使用
数组（array)
Arrays是Java提供的一个工具类，主要用来操作和使用数组。
java.util.Arrays
注：CTRL+ 鼠标左键进入Arrays的源码
- 排序
package com.openlab.search.cls;
import java.util.Arrays;
//排序
public class TestArrays {
public static void main(String[] args) {
int [] arr = {1,2,9,-100,-55,23,-99,0,3,4,8};
Arrays.sort(arr);
//底层使用的是快速排序
for(int i:arr) {
System.out.print(i + ",");
}
}
}
- 返回下标
package com.openlab.search.cls;
import java.util.Arrays;
public class TestArrays01 {
public static void main(String[] args) {
int [] arr = {1,2,9,-100,-55,23,-99,0,3,4,8};
Arrays.sort(arr);
int index = Arrays.binarySearch(arr, 8);
System.out.println(index);
}
}
- 填充
package com.openlab.search.cls;
import java.util.Arrays;
public class TestArrays02 {
public static void main(String[] args) {
int[] arr = new int[5];
Arrays.fill(arr, 5);
for (int i:arr) {
System.out.print(i + ",");
}
}
}
拷贝
最后
以上就是畅快便当为你收集整理的23 eclipse、数组、排序和查找算法第一个IDE——eclipseeclipse的常见配置数组作业题排序和查找算法Arrays类的学习和使用的全部内容，希望文章能够帮你解决23 eclipse、数组、排序和查找算法第一个IDE——eclipseeclipse的常见配置数组作业题排序和查找算法Arrays类的学习和使用所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复