java基礎05

最新推荐文章于 2024-07-01 20:57:37 发布
最新推荐文章于 2024-07-01 20:57:37 发布
阅读量164 收藏 1
点赞数
文章标签： java基礎 數組部分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44423114/article/details/100864343
版权

数组

数组的概念: 存储相同数据类型的一组连续的数据的容器【这个容器只在内存在有效】

数组的本质： 还是变量,只不过是一个容器变量,只不过这个变量中存储的不是基本数据类型,而是地址
注意: ：凡是变量中存放的是地址,那么这个变量一定引用数据类型
如何存放一个地址到变量中呢?
int a = 10;
String s = 0x0001;
将地址赋值给一个变量必须通过 new 的方式

数组声明的格式:

	数据类型[] 数组名; Java写法
	 int[] arr = null;
  	变式: 数据类型 数组名[]; C/C++ 写法
  	 int arr[] = null;

数组的初始化【动态初始化】

   数据类型[] 数组名 = new 数据类型[数组中元素的个数];
		double[] scores = new double[3];
		System.out.println(scores); // [D@7852e9

访问数组元素的格式:
数组名[下标/索引]
下标/索引 从0开始

数组的特点:

	1.既然数组也是一个变量,那么必须先声明再赋值再使用
  	2.这里的数据类型既可以是八大基本数据类型,也可以是引用数据类型
   	3.数组名的命名规范,和变量保持一致,但是一般是复数
   	The local variable scores may not have been initialized
   	4.数组是引用数据类型,默认没有地址需要赋值为null

ArrayIndexOutOfBoundsException
异常名称: 数组索引超出边界异常
产生原因: 索引不在 [0,数组的长度-1)
解决办法: 检查索引是否在范围之内

NullPointerException
异常名称: 空指针异常
产生原因: 对象[数组 类]没有new,就访问了对象的元素、内容,没有new就没有地址,没有地址就没有指针
解决办法: 找到相对应错误行的那个引用类型,new之

数组的初始化

动态初始化: 初始化的同时不给出默认值,由系统给出默认值,默认值的规则满足堆区默认值的规则,必须指定数组的长度
数据类型[] 数组名 = new 数据类型[数组中元素的个数];

静态初始化: 初始化的同时给出元素的值,系统会根据给出元素的个数去计算数组的长度大小,不需要指定数组的长度
格式一: 数据类型[] 数组名 = {元素1, 元素2, 元素3, … 元素n };

	int[] arr = { 11, 22, 33, 44, 55 };

		***格式二:***   数据类型[] 数组名 = new int[] {元素1, 元素2, 元素3, ... 元素n };

arr = new int[] { 77, 88, 99, 100, 101 };
数组的遍历: 访问数组的每一个元素

例：

	 功能: 遍历数组
	 返回值类型: void
	 参数列表: int[] arr
	 方法名: printArray
	
	public static void printArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
	
	public static void printArray(double[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}

大家不需要自己遍历,系统JRE提供了一个工具类叫做 Arrays,这里面提供了遍历的方法

System.out.println("===================");
		System.out.println(Arrays.toString(arr));
		System.out.println(Arrays.toString(arr2));

快速初始化的三种方式:
1.通过静态初始化

int[] arr = { 11, 22, 33, 44, 55 };

​ 2.通过键盘输入

Scanner input = new Scanner(System.in);

​ 3.通过随机数

//书写一个方法生成任意范围的随机数
	public static int getRandomNum(int start, int end) {
		return (int) (Math.random() * (end - start + 1) + start);
	}
}

值传递和引用传递
传递: 实参传递形参的过程
形参的类型可以是基本数据类型,也可以是引用数据类型

public class ArrayDemo05 {
	public static void main(String[] args) {
		
		int a = 10;
		System.out.println("方法调用前a的值为: " + a);  //值为 10
		
		change(a);
		
		System.out.println("方法调用后a的值为: " + a);  //值为 10
	}
	
	// 类型是基本数据类型的情况
	public static void change(int a) {
		a += 5;
		System.out.println("方法中a的值是: " + a);//值为 15
	}
}

总结: 当形参是基本数据类型的时候,值传递传递的数值本身

引用传递

形参是引用数据类型的情况
引用数类型
数组
类
接口

public class ArrayDemo06 {
	public static void main(String[] args) {
		int[] arr = {11, 22, 33};
		System.out.println("方法调用前数组中的元素是: " + Arrays.toString(arr));
		
		change(arr);
		
		System.out.println("方法调用前数组中的元素是: " + Arrays.toString(arr));
	}
	
	public static void change(int[] arr) {
		arr[1] = 666;
		System.out.println("方法调用中数组中的元素是: " + Arrays.toString(arr));
	}
}

总结:
当形参是基本数据类型的时候,传递的是数值本身
当形参是引用数据类型的时候,传递的是地址

当存在多个引用指向同一个堆区的空间的时候,有任何一个引用修改了堆区的内容,都会影响到所有的引用

基本查找

 功能: 查找某个数在数组中的索引
	 返回值类型: int
	 参数列表: int[] arr, int num
	 方法名: baiscSearch 【基本查找】
	 
	public static int basicSearch(int[] arr, int num) {
		int index = -1;
		
		for (int i = 0; i < arr.length; i++) {
			if (num == arr[i]) {
				index = i;
				break;
			}
		}
		
		return index;
	}
}

冒泡排序法: 相邻两个元素进行比较,如果左边的数大于后面的数,就交换两个数的位置,一趟比较结束后,最大值就出现在了最后面。

特点:
1.相邻两个元素进行比较,大者冒泡
2.一共比较 arr.length - 1 趟
3.每一趟比较的次数比上一趟少一次

分析代码部分：

		 * 第一趟排序:
		 * arr[0] 和 arr[1] 比较
		 * arr[1] 和 arr[2] 比较
		 * arr[2] 和 arr[3] 比较
		 * arr[3] 和 arr[4] 比较
		 * 
		 * 一共比较arr.length - 1次
		 */
		/*for (int i = 0; i < arr.length - 1 - 0; i++) {
			if (arr[i] > arr[i+1]) {
				int temp = 0;
				temp = arr[i];
				arr[i] = arr[i+1];
				arr[i+1] = temp;
			}
		}
		System.out.println("第一趟排序后: " + Arrays.toString(arr));
		
		
		 * 第二趟排序:
		 * arr[0] 和 arr[1] 比较
		 * arr[1] 和 arr[2] 比较
		 * arr[2] 和 arr[3] 比较
		 * 
		 * 一共比较arr.length - 1 - 1次
		 
		for (int i = 0; i < arr.length - 1 - 1; i++) {
			if (arr[i] > arr[i+1]) {
				int temp = 0;
				temp = arr[i];
				arr[i] = arr[i+1];
				arr[i+1] = temp;
			}
		}
		System.out.println("第二趟排序后: " + Arrays.toString(arr));
		
		
		 * 第三趟排序:
		 * arr[0] 和 arr[1] 比较
		 * arr[1] 和 arr[2] 比较
		 * 
		 * 一共比较arr.length - 1 - 2次
		 
		for (int i = 0; i < arr.length - 1 - 2; i++) {
			if (arr[i] > arr[i+1]) {
				int temp = 0;
				temp = arr[i];
				arr[i] = arr[i+1];
				arr[i+1] = temp;
			}
		}
		System.out.println("第三趟排序后: " + Arrays.toString(arr));
		
		
		
		 * 第四趟排序:
		 * arr[0] 和 arr[1] 比较
		 * arr[1] 和 arr[2] 比较
		 * 
		 * 一共比较arr.length - 1 - 3次
		 
		for (int i = 0; i < arr.length - 1 - 3; i++) {
			if (arr[i] > arr[i+1]) {
				int temp = 0;
				temp = arr[i];
				arr[i] = arr[i+1];
				arr[i+1] = temp;
			}
		}
		System.out.println("第四趟排序后: " + Arrays.toString(arr));*/

总结规律后代码部分：

public class BubbleSortDemo {
	public static void main(String[] args) {
	
		int[] arr = {24, 69, 80, 55, 13};
		
		System.out.println("排序前: " + Arrays.toString(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 temp = 0;
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		
		System.out.println("冒泡排序后: " + Arrays.toString(arr));
	}
	
	
}

插入排序：

思路
1.从第一个元素开始，该元素可以认为已经被排序
2.取出下一个元素，在已经排序的元素序列中从后向前扫描
3.如果该元素（已排序）大于新元素，将该元素移到下一位置
4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5.将新元素插入到该位置后
6.重复步骤2~5

分析代码部分：
/*
		 * 第一趟排序
		 * arr[1] 和 arr[0] 进行比较
		 * 比较一次
		 */
		/*int i = 1;
		for (int j = 0; j < 1; j++) {
			if (arr[i] < arr[j]) {
				int temp = 0;
				temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
		System.out.println("第一趟排序后: " + Arrays.toString(arr));
		
		
		 第二趟排序
		 * arr[2] 和 arr[0] 进行比较
		 * arr[2] 和 arr[1] 进行比较
		 * 比较2次
		 * 
		 
		i = 2;
		for (int j = 0; j < 2; j++) {
			if (arr[i] < arr[j]) {
				int temp = 0;
				temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
		System.out.println("第二趟排序后: " + Arrays.toString(arr));
		
		
		 第三趟排序
		 * arr[3] 和 arr[0] 进行比较
		 * arr[3] 和 arr[1] 进行比较
		 * arr[3] 和 arr[2] 进行比较
		 * 比较3次
		 * 
		 
		i = 3;
		for (int j = 0; j < 3; j++) {
			if (arr[i] < arr[j]) {
				int temp = 0;
				temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
		System.out.println("第三趟排序后: " + Arrays.toString(arr));
		
		
		  第四趟排序
		 * arr[4] 和 arr[0] 进行比较
		 * arr[4] 和 arr[1] 进行比较
		 * arr[4] 和 arr[2] 进行比较
		 * arr[4] 和 arr[3] 进行比较
		 * 比较4次
		 
		i = 4;
		for (int j = 0; j < 4; j++) {
			if (arr[i] < arr[j]) {
				int temp = 0;
				temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
		System.out.println("第四趟排序后: " + Arrays.toString(arr));*/

总结规律后代码部分：

public class InsertSortDemo {
	public static void main(String[] args) {
		int[] arr = {24, 69, 80, 55, 13};
		
		System.out.println("排序前: " + Arrays.toString(arr));
		for (int i = 1; i < arr.length ; i++) {
			for (int j = 0; j < i; j++) {
				if (arr[i] < arr[j]) {
					int temp = 0;
					temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
		System.out.println("插入排序后: " + Arrays.toString(arr));
	}
}
选择排序：

***选择排序思想:*** 从最左边开始,依次和后面每一个元素比较,
如果后面元素比第一个小,就交换位置,第一趟排序之后,最小数出现在了前面。

特点:
1.左边的值依次和后面每一个元素比较
2.一共比较了arr.length - 1 趟
3.每一趟比上一趟少比较1次

分析代码部分：
		 * 第一趟排序
		 * arr[0] 和 arr[1]
		 * arr[0] 和 arr[2]
		 * arr[0] 和 arr[3]
		 * arr[0] 和 arr[4]
		 * 
		 * 一共比较了arr.length - 1次
		
		/*int i = 0;
		for (int j = i+1; j < arr.length; j++) {
			if (arr[i] > arr[j]) {
				int temp = 0;
				temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
		System.out.println("第一趟排序后: " + Arrays.toString(arr));
		
		
		
		 * 第二趟排序
		 * arr[1] 和 arr[2]
		 * arr[1] 和 arr[3]
		 * arr[1] 和 arr[4]
		 
		i = 1;
		for (int j = i+1; j < arr.length; j++) {
			if (arr[i] > arr[j]) {
				int temp = 0;
				temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
		System.out.println("第二趟排序后: " + Arrays.toString(arr));
		
		
		
		 * 第三趟排序
		 * arr[2] 和 arr[3]
		 * arr[2] 和 arr[4]
		 
		i = 2;
		for (int j = i+1; j < arr.length; j++) {
			if (arr[i] > arr[j]) {
				int temp = 0;
				temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
		System.out.println("第三趟排序后: " + Arrays.toString(arr));
		
		
		
		 * 第四趟排序
		 * arr[3] 和 arr[4]
		 
		i = 3;
		for (int j = i+1; j < arr.length; j++) {
			if (arr[i] > arr[j]) {
				int temp = 0;
				temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
		System.out.println("第四趟排序后: " + Arrays.toString(arr));

总结规律后代码部分：

public class SelectSortDemo {
	public static void main(String[] args) {
		int[] arr = {44, 89, 100, 77, 33};
		
		System.out.println("排序前: " + Arrays.toString(arr));
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = i+1; j < arr.length; j++) {
				if (arr[i] > arr[j]) {
					int temp = 0;
					temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
		
		System.out.println("选择排序后: " + Arrays.toString(arr));
	}
}

快速排序法：

Arrays.sort(arr); ---> Arrays方法
二分法查找/折半查找：

​ 只针对排序好的元素再来进行二分。

/*
	 * 功能: 二分查找
	 * 返回值类型: int
	 * 参数列表: int[] arr, int num
	 * 方法名: binarySearch
	 */
	public static int binarySearch(int[] arr, int num) {
		// 1.定义最小索引和最大索引
		int min = 0;
		int max = arr.length - 1;
		
		// 2.计算中间索引
		int mid = (min + max) / 2;
		
		// 3.拿中间索引所对应的数值和需要查找的数 num 进行比较
		while (arr[mid] != num) {
			// 大了,左边找
			if (arr[mid] > num) {
				max = mid - 1;
			// 小了,右边找
			} else if (arr[mid] < num) {
				min = mid + 1;
			}
			
			if (min > max) {
				return -1;
			}
			
			// 重新计算中间索引
			mid = (min + max) / 2;
		}
		
		return mid;
	}
}
二维数组：

​ 概要：二维数组其实是一位数组的嵌套（每一行看做一个内层的一维数组）

二维数组内存结构：

[外链图片转存失败(img-m8E81XIU-1568552958129)(E:\JavaEE\javaSE\day05\01_课件资料\img\Snipaste_2019-09-14_16-16-49.png)]

两种初始化形式

格式1: 动态初始化

数据类型 数组名 [ ][ ] = new 数据类型[m][n]
数据类型 [ ][ ] 数组名 = new 数据类型[m][n]
数据类型 [ ] 数组名 [ ] = new 数据类型[m][n]

举例：int [ ][ ] arr=new int [5][3]; 也可以理解为“5行3例”

格式2: 静态初始化
数据类型 [ ][ ] 数组名 = {{元素1,元素2…},{元素1,元素2…},{元素1,元素2…}…};

举例：int [ ][ ] arr={{22,15,32,20,18},{12,21,25,19,33},{14,58,34,24,66},};

静态初始化可用于不规则二维数组的初始化

public static void main(String[]args){
int [][] arr=new int[][]{{4,5,6,8},{2,3},{1,6,9}};

	System.out.println(arr.length);//输出行数
	System.out.println(arr[0].length);//输出列数
	
}

输出结果：

[外链图片转存失败(img-nbHfADOC-1568552958143)(E:\JavaEE\javaSE\day05\01_课件资料\img\Snipaste_2019-09-14_16-16-26.png)]

例：

实现一个M*N的二维数组的转置并输出：

public static void main(String[]args){
		int [][] arr=new int[][]{{4,5,6},{2,3,9}};
		int [][]arrtrans=new int[arr[0].length][arr.length];
        for(int i=0;i<arr.length;i++){
        	for(int j=0;j<arr[0].length;j++){
        		arrtrans[j][i]=arr[i][j];
        	}
        }
        for(int i=0;i<arrtrans.length;i++){
        	for(int j=0;j<arrtrans[0].length;j++){
        		System.out.print(arrtrans[i][j]);		
        	}
        	System.out.println();
        }
	}
臭dd
关注
Java基础
qq_53466247的博客
07-17 6093
20世纪90年代，单片式计算机系统诞生，单片式计算机系统不仅廉价，而且功能强大，使用它可以大幅度提升消费性电子产品的智能化程度SUN公司为了抢占市场先机，在1991年成立了一个由詹姆斯·高斯林（James Gosling）领导，名为“Green”项目小组，目的是开发一种能够在各种消费性电子产品上运行的程序架构那么使用何种编程语言来设计，是项目小组头疼的事。
Java语言基础
热门推荐
蜗小牛的博客
09-14 3万+
Java语言基础 Java标识符是以字母、下划线或符号$开头，后接字母、下划线、符...
【Java基础05】枚举类
qq_42247619的博客
02-28 1772
总结描述Java基础中枚举类的定义和使用，包括枚举类的定义、枚举类的常用方法、枚举类的参数和方法、枚举实现单例模式。
Java基础05 循环结构
2401_84831762的博客
05-11 1009
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
Java基础05—泛型和Lambda表达式
spark2010的博客
03-07 2261
本文是学习Java时所记录的学习笔记，本节包含了泛型和Lambda表达式的介绍。
java基础-05
anan的博客
11-09 4358
java基础05
Java基础篇 | Java基础语法
分享思想，留下痕迹。
05-31 1万+
Java以前自学过一写，现在工作了，时间太久有一些知识都遗忘了，今天开始就更新Java了，想着把之前的Java基础知识捡起来；从最基础的开始，打好Java基础，便于以后复习。也欢迎大家跟我一起复习。Java中，字面量指的是在程序中直接使用的数据，字面量是Java中最基本的表达式，不需要进行计算或转换，直接使用即可。基本数据类型整数类型：包括byteshortint和long四种类型，用于表示整数。浮点类型：包括float和double两种类型，用于表示带小数点的数值。boolean。
Java基础习题库
qq_61524266的博客
10-22 1万+
习题库
Java05基础 数组
summer_9823的博客
05-15 1336
一维数组、二维数组（静态初始化、动态初始化、遍历、变量访问、内存解析图、常见异常）
Java知识点汇总--基础篇
m0_74194490的博客
07-01 2659
异常就是程序在运行时出现的意外情况，而导致程序无法正常往下执行[终止了]当系统提供的异常类型无法满足客户需求时，程序员可以自己定义异常类型。目的可以达到见名知意创建一个异常类并继承RuntimeException//创建一个构造函数super(msg);使用自定义的异常类。
完整版Java全套入门培训课件 Java基础 05-多线程（共12页）.pptx
08-22
Java多线程是Java编程中一个非常重要的概念，它允许程序同时执行多个任务，从而提高系统资源利用率和程序性能。在Java中，多线程主要涉及到以下几个关键知识点： 1. **进程与线程**： - **进程**：是操作系统分配...
完整版Java全套入门培训课件 Java基础 05-多线程（共12页）.rar
09-29
通过本套Java基础培训课件，你将全面理解Java多线程的概念、机制以及实际应用，为后续的高级编程和系统级开发打下坚实的基础。学习过程中，结合实践案例进行练习，将有助于更好地理解和掌握这些知识点。
Java基础入门教程 Java语言基础 第05课 基础算法 共26页.pptx
07-07
【课程大纲】 Java基础入门教程 Java语言基础 第01课 准备环境 共39页.pptx Java基础入门教程 Java语言基础 第02课 Java变量 共28页.pptx ...Java基础入门教程 Java语言基础 第05课 基础算法 共26页.pptx
Java全套入门培训课件 Java基础 Java培训课程 全套PPT课件 共11个章节.rar
11-14
Java全套入门培训课件 Java基础 05-多线程（共12页）.pptx Java全套入门培训课件 Java基础 06-集合（共24页）.pptx Java全套入门培训课件 Java基础 07-IO（共29页）.pptx Java全套入门培训课件 Java基础 08-GUI图形...
java基础课件.zip
06-10
这个名为"java基础课件.zip"的压缩包包含了某培训机构的教学资源，涵盖了从基础到进阶的Java学习内容，适合自学爱好者或者希望巩固Java基础知识的人群。下面将详细解读这些文件中的知识点： 1. **IDEA安装详解.pdf*...
yolov10预训练模型.rar
11-05
在按照YOLOv10官网上的步骤进行时，运行app.py文件时，如果没有预训练模型的话会报错。解压压缩包里的内容到同级目录下（在requirements.txt文档下面），这样运行后就不会报错。
Linux Socket编程、IO模型及进程间通信的完整实用案例
最新发布
11-05
在IT领域，Linux系统是广泛应用于服务器和嵌入式设备的操作系统。对于系统开发者和管理员，深入理解Linux的Socket编程、IO模型以及进程间通信（IPC）是至关重要的。本资料包提供了三个主要部分的学习资源：`process_comm`涉及进程间通信，`linux_socket`涵盖Socket编程，而`io_mode`则讨论Linux的IO模型。接下来，我们将详细探讨这些关键知识点。 让我们来看看**Linux Socket编程**。Socket是网络通信的基本接口，它允许两个或多个进程通过网络进行数据交换。在Linux中，Socket编程通常涉及到以下步骤：创建Socket，绑定IP地址和端口号，监听连接请求，接受连接，发送和接收数据，最后关闭Socket。`linux_socket`目录可能包含了示例代码，演示如何创建TCP或UDP Socket，处理并发连接，以及实现基本的错误处理机制。理解Socket编程有助于开发网络服务，如Web服务器、FTP服务器等。 我们来讨论**Linux IO模型**。在Linux中，有五种主要的IO模型：阻塞IO、非阻塞IO、IO复用（
apsw-3.38.5.post1-cp310-cp310-win_amd64.whl.rar
11-05
python whl离线安装包 pip安装失败可以尝试使用whl离线安装包安装 第一步 下载whl文件，注意需要与python版本配套 python版本号、32位64位、arm或amd64均有区别 第二步 使用pip install XXXXX.whl 命令安装，如果whl路径不在cmd窗口当前目录下，需要带上路径 WHL文件是以Wheel格式保存的Python安装包， Wheel是Python发行版的标准内置包格式。 在本质上是一个压缩包，WHL文件中包含了Python安装的py文件和元数据，以及经过编译的pyd文件， 这样就使得它可以在不具备编译环境的条件下，安装适合自己python版本的库文件。 如果要查看WHL文件的内容，可以把.whl后缀名改成.zip，使用解压软件（如WinRAR、WinZIP）解压打开即可查看。 为什么会用到whl文件来安装python库文件呢？ 在python的使用过程中，我们免不了要经常通过pip来安装自己所需要的包， 大部分的包基本都能正常安装，但是总会遇到有那么一些包因为各种各样的问题导致安装不了的。 这时我们就可以通过尝试去Python安装包大全中（whl包下载）下载whl包来安装解决问题。
aiohttp-3.6.2-cp35-cp35m-win32.whl.rar
11-05
python whl离线安装包 pip安装失败可以尝试使用whl离线安装包安装 第一步 下载whl文件，注意需要与python版本配套 python版本号、32位64位、arm或amd64均有区别 第二步 使用pip install XXXXX.whl 命令安装，如果whl路径不在cmd窗口当前目录下，需要带上路径 WHL文件是以Wheel格式保存的Python安装包， Wheel是Python发行版的标准内置包格式。 在本质上是一个压缩包，WHL文件中包含了Python安装的py文件和元数据，以及经过编译的pyd文件， 这样就使得它可以在不具备编译环境的条件下，安装适合自己python版本的库文件。 如果要查看WHL文件的内容，可以把.whl后缀名改成.zip，使用解压软件（如WinRAR、WinZIP）解压打开即可查看。 为什么会用到whl文件来安装python库文件呢？ 在python的使用过程中，我们免不了要经常通过pip来安装自己所需要的包， 大部分的包基本都能正常安装，但是总会遇到有那么一些包因为各种各样的问题导致安装不了的。 这时我们就可以通过尝试去Python安装包大全中（whl包下载）下载whl包来安装解决问题。
Java基础入门：Android开发基石
Java基础入门教程（Android必备基础）主要涵盖了Java编程语言的基础知识，特别强调了其在Android开发中的重要性。本教程分为两个主要部分：第1部分Java基础程序设计，以及与Android开发相关的知识。 在第1部分中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值