java 数据结构学习之（一）数组

最新推荐文章于 2022-07-12 22:20:29 发布
最新推荐文章于 2022-07-12 22:20:29 发布
阅读量675 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构
数组是应用最广泛的数据结构，也是最简单的数据结构，它有着结构简单，算法通俗易懂的优点。数组又分为有序数组和无序数组，我们通常用的都是无序数组。下面是这两种数组之间的区别

 

无序数组的优点：插入快，根据索引查找快。缺点：在未知数组位置的情况下查找慢，删除慢。

有序数组的优点：使用二分法查找快。缺点：插入数据和删除数据慢。因为插入数据要做排序操作。

 

综合以上，可以看出他们各自的使用场景，无序数组适合经常做插入操作和用索引访问的环境，而有序数组更趋向于随机查找。

 

下面是封装的一个数组类，扩展了了insert,delete,find方法,有许多不足之处，比如insert方法没有判断数组界限。懒得搞了。

 

Java代码 复制代码  收藏代码
  1. package ArrayDemo;   
  2.   
  3. public class HighArray {   
  4.        
  5.     private int[] arr = null;   
  6.     private int nElement = 0;//当前数组的实际长度   
  7.     public HighArray(int size){   
  8.         this.arr = new int[size];   
  9.         this.nElement = 0;   
  10.     }   
  11.        
  12.     /**查找指定元素是否在数组中存在，返回结果  
  13.      * @param c  
  14.      * @return  
  15.      */  
  16.     public boolean find(int c){   
  17.         int i;   
  18.         for ( i = 0; i < nElement && arr[i]!=c; i++);   
  19.         return i != nElement;   
  20.     }   
  21.        
  22.     /**插入  
  23.      * @param c  
  24.      */  
  25.     public void insert(int c){   
  26.         arr[nElement++] = c;   
  27.     }   
  28.        
  29.     /**删除  
  30.      * @param c  
  31.      * @return  
  32.      */  
  33.     public boolean delete(int c){   
  34.         int i;   
  35.         for ( i = 0; i < nElement && arr[i]!=c; i++);   
  36.         if(i!=nElement){   
  37.             nElement--;   
  38.             for (int j = i; j < nElement; j++) {   
  39.                 arr[j] = arr[j+1];   
  40.             }   
  41.             return true;   
  42.         }else{   
  43.             return false;   
  44.         }   
  45.     }   
  46.        
  47.     /**获取当前最大元素  
  48.      * @return  
  49.      */  
  50.     public int getMax(){   
  51.         if(nElement > 0){   
  52.             int max = arr[0];   
  53.             for (int i = 1; i < nElement; i++) {   
  54.                 if(arr[i] > max)max = arr[i];   
  55.             }   
  56.             return max;   
  57.         }   
  58.         return -1;   
  59.     }   
  60.        
  61.     /**删除并且返回最大元素  
  62.      * @return  
  63.      */  
  64.     public int removeMax(){   
  65.         if(nElement > 0){   
  66.             int max = arr[0];   
  67.             for (int i = 1; i < nElement; i++) {   
  68.                 if(arr[i] > max)max = arr[i];   
  69.             }   
  70.             delete(max);   
  71.             return max;   
  72.         }   
  73.         return -1;   
  74.     }   
  75.        
  76.     public void display(){   
  77.         for (int i = 0; i <nElement; i++) {   
  78.             System.out.println(arr[i]);   
  79.         }   
  80.     }   
  81.        
  82.     /**  
  83.      * 删除数组中存在的重复元素并缩小数组长度  
  84.      */  
  85.     public void noDup(){   
  86.         int count  = 0;   
  87.         for (int i = 0; i < nElement; i++) {   
  88.             if(arr[i] != -1){// -1为空值的表现   
  89.                 for (int j = 0; j < nElement; j++) {   
  90.                     if(i!=j && arr[i] == arr[j]){   
  91.                         arr[j] = -1;   
  92.                         count++;   
  93.                     }   
  94.                 }   
  95.             }   
  96.                
  97.         }   
  98.         if(count > 0){   
  99.             int j = 0;   
  100.             for (int i = 0; i < nElement; i++) {   
  101.                 if(arr[i]!=-1){   
  102.                     arr[j++] = arr[i];   
  103.                 }   
  104.             }   
  105.             for (int k = j; k < nElement; k++) {   
  106.                 arr[k] = 0;   
  107.             }   
  108.         }   
  109.        
  110.         nElement-=count;   
  111.            
  112.     }   
  113.        
  114.     /**  
  115.      * @param args  
  116.      */  
  117.     public static void main(String[] args) {   
  118.         // TODO Auto-generated method stub   
  119.         HighArray h = new HighArray(100);   
  120.             h.insert(7);   
  121.             h.insert(74);   
  122.             h.insert(74);   
  123.             h.insert(74);   
  124.             h.insert(89);   
  125.             h.insert(12);   
  126.             h.insert(8);   
  127.             h.noDup();   
  128.             h.display();   
  129.         //  h.delete(12);   
  130.                
  131.     }   
  132.        
  133.        
  134. }  
package ArrayDemo;

public class HighArray {
	
	private int[] arr = null;
	private int nElement = 0;//当前数组的实际长度
	public HighArray(int size){
		this.arr = new int[size];
		this.nElement = 0;
	}
	
	/**查找指定元素是否在数组中存在，返回结果
	 * @param c
	 * @return
	 */
	public boolean find(int c){
		int i;
		for ( i = 0; i < nElement && arr[i]!=c; i++);
		return i != nElement;
	}
	
	/**插入
	 * @param c
	 */
	public void insert(int c){
		arr[nElement++] = c;
	}
	
	/**删除
	 * @param c
	 * @return
	 */
	public boolean delete(int c){
		int i;
		for ( i = 0; i < nElement && arr[i]!=c; i++);
		if(i!=nElement){
			nElement--;
			for (int j = i; j < nElement; j++) {
				arr[j] = arr[j+1];
			}
			return true;
		}else{
			return false;
		}
	}
	
	/**获取当前最大元素
	 * @return
	 */
	public int getMax(){
		if(nElement > 0){
			int max = arr[0];
			for (int i = 1; i < nElement; i++) {
				if(arr[i] > max)max = arr[i];
			}
			return max;
		}
		return -1;
	}
	
	/**删除并且返回最大元素
	 * @return
	 */
	public int removeMax(){
		if(nElement > 0){
			int max = arr[0];
			for (int i = 1; i < nElement; i++) {
				if(arr[i] > max)max = arr[i];
			}
			delete(max);
			return max;
		}
		return -1;
	}
	
	public void display(){
		for (int i = 0; i <nElement; i++) {
			System.out.println(arr[i]);
		}
	}
	
	/**
	 * 删除数组中存在的重复元素并缩小数组长度
	 */
	public void noDup(){
		int count  = 0;
		for (int i = 0; i < nElement; i++) {
			if(arr[i] != -1){// -1为空值的表现
				for (int j = 0; j < nElement; j++) {
					if(i!=j && arr[i] == arr[j]){
						arr[j] = -1;
						count++;
					}
				}
			}
			
		}
		if(count > 0){
			int j = 0;
			for (int i = 0; i < nElement; i++) {
				if(arr[i]!=-1){
					arr[j++] = arr[i];
				}
			}
			for (int k = j; k < nElement; k++) {
				arr[k] = 0;
			}
		}
	
		nElement-=count;
		
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HighArray h = new HighArray(100);
			h.insert(7);
			h.insert(74);
			h.insert(74);
			h.insert(74);
			h.insert(89);
			h.insert(12);
			h.insert(8);
			h.noDup();
			h.display();
		//	h.delete(12);
			
	}
	
	
}

 

 上面是对一个无序数组做了一些封装和扩展。实现起来稍微简单点。下面介绍下有序数组的二分查找法。

 要实现二分查找法数组必须先满足两个条件1.必须采用顺序存储结构 2.必须按关键字大小有序排列。

二分查找法的基本原理就是：逐渐缩小查询范围，直到查找到元素或者查找不到此元素。它的优点是查找次数较线性查找（也就是按顺序查找所有元素）要高，而且当数组越大时查找次数的优势较线性查找越明显。下面是它查找不同数据量所需要的次数



 怎么样，是不是数据量越大查找次数的优势就越大，比如在10000里查找一个元素，线性查找需要的平均次数是1000/2 = 5000次， 而二分查找法的计算公式是以二为基数的对数 ，所谓对数就是指数的反函数 ，一般计算器的log函数就是以10为基数的对数，那么计算10000的二分查找法所需次数的公式就是log(10000) * 3.322 ，乘以3.322是因为要将该结果从10的基数转换成2的基数，这样下来四舍五入差不多就是所需次数了。结果是 13.288 取整就是14次。5000比14可想而知效率高了多少。ps:也可以这样计算log2(x) = log(x) / log(2) 

 

 

下面是二分法查找的基本步骤（假如是数组元素升序排序的）

1.将需查找元素和数组中间的元素比较，如果相等则返回，如果数组中间元素比需查找元素大则说明目标元素的位置在中间元素的前面，反之在后面。

2.通过步骤1，已经缩小了一半的范围，然后重复步骤1，直到找到元素或者找不到元素为止，就算找不到也最多就是查找Math.ceil(log(数据长度）* 3.322 )次。

 

 

这有点象我们平常的猜数游戏


java代码二分法实现 

 

Java代码 复制代码  收藏代码
  1. public int bianrySearch(int[] arr,int searchKey){   
  2.         int lowerBound = 0, upperBound = arr.length - 1;   
  3.         while(lowerBound <= upperBound){   
  4.             int curIn = (lowerBound + upperBound)/2;   
  5.             if(arr[curIn] == searchKey){   
  6.                 return curIn;   
  7.             }else if(arr[curIn] > searchKey){   
  8.                 upperBound = curIn - 1;   
  9.             }else{   
  10.                 lowerBound = curIn + 1;   
  11.             }   
  12.         }   
  13.         return  src.length;   
  14.     }  
public int bianrySearch(int[] arr,int searchKey){
		int lowerBound = 0, upperBound = arr.length - 1;
		while(lowerBound <= upperBound){
			int curIn = (lowerBound + upperBound)/2;
			if(arr[curIn] == searchKey){
				return curIn;
			}else if(arr[curIn] > searchKey){
				upperBound = curIn - 1;
			}else{
				lowerBound = curIn + 1;
			}
		}
		return  src.length;
	}

 看的不是很懂？没关系，看下面一张图您可能就明白了。


 

就是二分法这样逐渐缩小查询范围的原理来实现的。

 

下面是一个用二分法实现了find,delete,insert方法的数组类

 

Java代码 复制代码  收藏代码
  1. package ArrayDemo;   
  2.   
  3. public class OrderArray {   
  4.     private int[] arr = null;   
  5.     private int nElement = 0;   
  6.     public OrderArray(int size){   
  7.         this.arr = new int[size];   
  8.         this.nElement = 0;   
  9.     }   
  10.        
  11.     public int find(int c){   
  12.         int lowerBound = 0, upperBound = nElement - 1;   
  13.         while(lowerBound <= upperBound){   
  14.             int middle = (lowerBound + upperBound)/2;   
  15.             if(arr[middle] == c){   
  16.                 return middle;   
  17.             }else if(arr[middle] > c){   
  18.                 upperBound = middle - 1;   
  19.             }else{   
  20.                 lowerBound = middle + 1;   
  21.             }   
  22.         }   
  23.         return nElement;   
  24.     }   
  25.            
  26.     private int doSearchRecursive(int lower,int upper,int c){   
  27.         while(lower <= upper){   
  28.             int middle = (lower + upper)/2;   
  29.             if(arr[middle]==c){   
  30.                 return middle;   
  31.             }else if(arr[middle] < c){   
  32.                 return doSearchRecursive(middle + 1, upper, c);   
  33.             }else{   
  34.                 return doSearchRecursive(lower, middle -1, c);   
  35.             }   
  36.         }   
  37.         return nElement;   
  38.     }   
  39.        
  40.        
  41.     /**二分法递归实现  
  42.      * @param c  
  43.      * @return  
  44.      */  
  45.     public int findRecursive(int c){   
  46.         return doSearchRecursive(0,arr.length - 1,c);   
  47.     }  
package ArrayDemo;

public class OrderArray {
	private int[] arr = null;
	private int nElement = 0;
	public OrderArray(int size){
		this.arr = new int[size];
		this.nElement = 0;
	}
	
	public int find(int c){
		int lowerBound = 0, upperBound = nElement - 1;
		while(lowerBound <= upperBound){
			int middle = (lowerBound + upperBound)/2;
			if(arr[middle] == c){
				return middle;
			}else if(arr[middle] > c){
				upperBound = middle - 1;
			}else{
				lowerBound = middle + 1;
			}
		}
		return nElement;
	}
		
	private int doSearchRecursive(int lower,int upper,int c){
		while(lower <= upper){
			int middle = (lower + upper)/2;
			if(arr[middle]==c){
				return middle;
			}else if(arr[middle] < c){
				return doSearchRecursive(middle + 1, upper, c);
			}else{
				return doSearchRecursive(lower, middle -1, c);
			}
		}
		return nElement;
	}
	
	
	/**二分法递归实现
	 * @param c
	 * @return
	 */
	public int findRecursive(int c){
		return doSearchRecursive(0,arr.length - 1,c);
	}
Java代码 复制代码  收藏代码
  1.     public void insert(int c){   
  2.         int lowerBound = 0,upperBound = nElement -1,max = nElement;   
  3.         while(lowerBound <= upperBound ){//用二分法查找在数组中第一个比c大的元素   
  4.             int middle = (lowerBound + upperBound)/2;   
  5.             if(arr[middle] == c){   
  6.                 max = middle;   
  7.                 break;   
  8.             }else if(arr[middle] > c){   
  9.                 max = middle;   
  10.                 upperBound = middle - 1;   
  11.             }else{   
  12.                 lowerBound = middle + 1;   
  13.             }   
  14.         }   
  15.         //移动数组   
  16.         for (int i = nElement; i > max; i--) {   
  17.             arr[i] = arr[i - 1];   
  18.         }   
  19.         arr[max] = c;   
  20.         nElement++;   
  21.     }   
  22.        
  23.     /**将两个有序的数组合并成一个有序的数组  
  24.      * @param src1   
  25.      * @param src2  
  26.      */  
  27.     public void mearge(int[] src1,int[] src2){   
  28.         int[] tar = new int[src1.length + src2.length];   
  29.         for (int i = 0,k=0,j=0; i < tar.length; i++) {   
  30.             if(j >= src2.length || (k < src1.length && src1[k] < src2[j])){   
  31.                 tar[i] = src1[k++];   
  32.             }else{   
  33.                 tar[i] = src2[j++];   
  34.             }   
  35.         }   
  36.         for (int i = 0; i < tar.length; i++) {   
  37.             System.out.println(tar[i]);   
  38.         }   
  39.            
  40.     }   
  41.     public boolean delete(int c){   
  42.         int index = find(c);   
  43.         if(index != nElement--){   
  44.             for (int i = index; i < nElement; i++) {   
  45.                 arr[i] = arr[i + 1];   
  46.             }   
  47.             return true;   
  48.         }else{   
  49.             return false;   
  50.         }   
  51.     }   
  52.        
  53.     public int[] getArr(){   
  54.         return this.arr;   
  55.     }   
  56.     public void display(){   
  57.         for (int i = 0; i <nElement; i++) {   
  58.             System.out.println(arr[i]);   
  59.         }   
  60.     }   
  61.     /**  
  62.      * @param args  
  63.      */  
  64.     public static void main(String[] args) {   
  65.         // TODO Auto-generated method stub   
  66.         OrderArray h1 = new OrderArray(12);   
  67.         for (int i = 0; i < 12; i++) {   
  68.             h1.insert((int)(Math.random() * 1000));   
  69.         }   
  70.     //  h1.display();   
  71.         OrderArray h2 = new OrderArray(10);   
  72.         for (int i = 0; i < 10; i++) {   
  73.             h2.insert((int)(Math.random() * 1000));   
  74.         }   
  75.         h1.mearge(h1.getArr(), h2.getArr());   
  76.     //  System.out.println(h.find(34));   
  77.     }   
  78.        
  79. }  
	public void insert(int c){
		int lowerBound = 0,upperBound = nElement -1,max = nElement;
		while(lowerBound <= upperBound ){//用二分法查找在数组中第一个比c大的元素
			int middle = (lowerBound + upperBound)/2;
			if(arr[middle] == c){
				max = middle;
				break;
			}else if(arr[middle] > c){
				max = middle;
				upperBound = middle - 1;
			}else{
				lowerBound = middle + 1;
			}
		}
		//移动数组
		for (int i = nElement; i > max; i--) {
			arr[i] = arr[i - 1];
		}
		arr[max] = c;
		nElement++;
	}
	
	/**将两个有序的数组合并成一个有序的数组
	 * @param src1 
	 * @param src2
	 */
	public void mearge(int[] src1,int[] src2){
		int[] tar = new int[src1.length + src2.length];
		for (int i = 0,k=0,j=0; i < tar.length; i++) {
			if(j >= src2.length || (k < src1.length && src1[k] < src2[j])){
				tar[i] = src1[k++];
			}else{
				tar[i] = src2[j++];
			}
		}
		for (int i = 0; i < tar.length; i++) {
			System.out.println(tar[i]);
		}
		
	}
	public boolean delete(int c){
		int index = find(c);
		if(index != nElement--){
			for (int i = index; i < nElement; i++) {
				arr[i] = arr[i + 1];
			}
			return true;
		}else{
			return false;
		}
	}
	
	public int[] getArr(){
		return this.arr;
	}
	public void display(){
		for (int i = 0; i <nElement; i++) {
			System.out.println(arr[i]);
		}
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		OrderArray h1 = new OrderArray(12);
		for (int i = 0; i < 12; i++) {
			h1.insert((int)(Math.random() * 1000));
		}
	//	h1.display();
		OrderArray h2 = new OrderArray(10);
		for (int i = 0; i < 10; i++) {
			h2.insert((int)(Math.random() * 1000));
		}
		h1.mearge(h1.getArr(), h2.getArr());
	//	System.out.println(h.find(34));
	}
	
}

 

这就是对数组的二分查找法基本的学习。

Tpache
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java数组结构图
11-15
对数组的总结和分析，通过这个结构记住它，在开发的过程中使用
java数组的结构_Java数组浅析
weixin_42140846的博客
02-12 298
数组(array)是相同类型变量的集合，可以使用共同的名字引用它。数组可被定义为任何类型，可以是一维或多维。数组中的一个特别要素是通过下标来访问它。数组提供了一种将有联系的信息分组的便利方法。注意：如果你熟悉C/C++，请注意， Java数组的工作原理与它们不同。1、数组不是集合，它只能保存同种类型的多个原始类型或者对象的引用。数组保存的仅仅是对象的引用，而不是对象本身。2、数组本身就是对象，Ja...
Java数据结构数组
Madridcrls7的博客
08-02 433
数组 自定义数组类MyOrderArray实现数组的增删改查 public class MyOrderArray { private long [] arr; private int elements; //表示数组的有效数据的个数 public MyOrderArray(){ arr=new long[50]; //设置长度为50 } public MyOrderA...
java中数组的数据结构_Java数据结构与算法（一）--数组
weixin_34587698的博客
02-13 128
目录数组是应用最广泛的数据存储结构。它被植入大部分的编程语音。在Java中数组用来存放一种类型的集合。1.数组的介绍①数组的声明第一种方式：int[] arr = new int[10];//数组类型[] 数组名称 = new 数组类型 [数组大小];创建数组并声明数组大小第二种方式：int[] arr = new int[]{1,2,3,4};//数组类型[] 数组名称 = new 数组类型[数...
JAVA数据结构之数组详细教程
01-21
本文整理了java数据结构的数组操作。希望对刚入门数据结构的同志们有帮助。 java数组非常简单。只要有JAVA语言基础就可以看这篇博文。大家不要害怕。。。非常简单。。 整理博客真的很花费时间，如果对大家有帮助，...
java数据结构和算法中数组的简单入门
08-25
Java数据结构和算法中数组的简单入门 在 Java 数据结构和算法中，数组是最基本也是最重要的一种数据结构。数组是一种固定长度的数据集合，可以存储同类型的数据元素。下面是关于 Java 数组的简单入门知识点： 一、...
Java数据结构学习笔记
12-18
### Java数据结构学习笔记知识点详解 #### 一、数据结构与算法基础 1. **数据结构定义** - 数据结构是一门研究组织数据方式的学科，它与编程语言紧密相关，是实现高效程序设计的基础。 - 在软件开发中，合理选择...
Java数组是一种数据结构.txt
10-15
Java数组是一种数据结构
Java数据结构学习资料源码.zip
最新发布
01-07
这份"Java数据结构学习资料源码.zip"包含了一系列与数据结构相关的学习资源，特别针对Java初学者，提供详细的代码案例，帮助他们从实践中理解这些基础概念。 首先，让我们探讨一下数据结构的基本概念。数据结构是...
Java数组之一维数组
Bald_Creator的博客
02-14 234
一、概述 1、数组概述 数组是相同类型的数据按顺序组成的一种引用数据类型 数据类型 包括基本数据类型和引用数据类型 引用数据类型包括类、接口和数组 一维数组：声明、创建、初始化、元素的引用、长度、应用 2、数组的概念 数组声明： 1）数据类型[] 数组名; 2）数据类型 数组名[]; 数组创建： 1）格式一：先声明后创建 数据类型[] 数组名; 数组名 = new 数据类型[数组长度]; usage: int[] arr; arr = new int[10]; // 创建一个长度为10的整型数组 2）格式
java算法篇(一)：冒泡排序
weixin_41377877的博客
03-24 130
排序算法是java中的基础算法，很多面试题中都会涉及，今天就来介绍一下冒泡排序： 有一个int数组：int srcArray[] = {3,50,20,95,30,101,78,17,28,21,81,11,32,23}，将其从小到大排序并输出。 分析：冒泡排序的原理是两两比较，比如，第一次排序，先比较3、50，不用调换顺序；循环再比较50、20，需要调换顺序，这时候数组就是这样：{3,20,50,95,30,101,78,17,28,21,81,11,32,23}；循环再比较50、95，以此类推，第一
Java基础篇：数组
热门推荐
张维鹏的博客
10-10 3万+
数组是一种线性数据结构，是一个使用连续的内存空间存放相同的数据类型的集合容器，与其他容器相比，数组的区别主要在于性能与保存基本类型的能力。 在Java中，数组是一种效率最高的存储和随机访问对象的方式，通过寻址公式，随机访问的时间复杂可以达到O(1)，但是为了保持空间的连续性，在数组中插入、删除数据时，都需要移动后面数据，该操作的时间复杂度为O(n)。另外，由于空间上连续，所以数组对CPU缓存比较友好，借助CPU的缓存机制，预读数组中的数据，提高访问效率。但是，由于数组是定长
【Java基础知识 31】Java数组详解
学Java，找哪吒
11-15 6051
数组是一种数据结构，是用来存储同一类型值的集合。通过一个整形下标可以访问数组中的每一个值。
Java实现基本数据结构——数组
07-12 1950
首先，我们先设计一个静态的数组，以int数组为例。不考虑扩容，先从最简单的类来理解数组的基本功能。 数组可以表示为下图：上图代表一个容量为7，里面每个空间存储了一个int类型的 1 ，这样一个数组。 数组最大的优点就是通过索引值快速查询数据，比如array[2]可以快速查询到第三个空间中的数据 1 。根据这个优点，我们可以想到，数组比较适合存储索引有语义的数据，比如成绩单这种，我们把名次当做索引，分数当做数据用一个数组存储起来，就可以快速获取某个名次的分数。 按照这个数组，我们可以设计一个数组类，首先设计好
java数组的结构_详解Java数据结构之数组(Array)
weixin_30015509的博客
02-12 516
开始本文前，先跟大家推荐个知识星球：小猿和他的朋友们，目前星球还在优惠阶段，大家可以点进来看看 。今天重点介绍下数组的概念，数据就是一种数据结构，可以用来存储多个数据，每个数组中可以存放相同类型的数据。比如，在学校，我们是一个班，这里的班级中每个同学都是这个班级数组中的元素，都是同样的类型为学生，对应的学号就是我们的索引，但是在现实中的学号一般都是从1开始的，而在Java中的数组索引是从0开始的...
学习-Java数组之一维字符数组之大小写转换
drizzle2333的博客
11-13 4195
任务描述 本关任务：实现一维字符数组的大小写转换，将数组中的大写字母转化为小写字母，小写字母转化为大写字母，最后输出转换后的字符数组。 相关知识 为了完成本关任务，你需要掌握： 1.一维字符数组的创建； 2.一维字符数组的初始化。 数组对于每一门编程语言来说都是重要的数据结构之一，Java 语言中提供的数组是用来存储固定大小的同类型元素。下面我们将介绍用于存储字符的一维数组。 创建一维字符数组 Java 语言使用 new 操作符来创建数组，语法如下： 数据类型[] 数组名 = new
java中的数据结构——数组
lx_Frolf的博客
10-24 1306
在Java中，数组非常常用，大部分的数据结构也是基于数组来实现的。 与数组有关的话题： 1.在java中，声明一个数组过程中，是如何分配内存的？ A. 当声明数组类型变量时，为其分配了（32位）引用空间，由于未赋值，因此并不指向任何对象； B.当创建了一个数组对象（也就是new出来的）并将其地址赋值给了变量，其中创建出来的那几个数组元素相当于引用类型变量，因此各自占用（32位的）引用空间并按其默认...
Java数据结构详解：从数组到向量
Java数据结构是编程基础的重要组成部分，它涉及到如何高效地存储和操作数据。在这个主题中，我们将深入探讨Java中常见的数据结构，包括数组、向量和字符处理。 首先，我们来看一维数组。数组是一种线性数据结构，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值