「java顺序循环选择」java实现选择排序
本篇文章给大家谈谈java顺序循环选择，以及java实现选择排序对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
Java二重循环执行顺序是什么
java二重循环就是指外层一个循环，在外层循环里面嵌套一个循环。外层循环一次，内层循环全部，也就是里面的循环要执行外层循环*内层循环的次数。这里以for循环举例。如下图
for(int i = 0 ; i5 ; i++){
for(int j = 0 ; j5 ; j++){
}
}
先执行外层的for循环一次，这里i=0，然后执行内层的for循环5次从0--5。
然后重新执行外层的for循环，这里i=1,然后执行内层的for循环5次从0--5。
所以是外层循环执行了5次，内层循环执行了25次。
用java语言设计顺序循环队列类
代码如下：
import java.io.Serializable;
import java.util.Arrays;
public class LoopQueueT implements Serializable {
/**
* @Fields serialVersionUID : TODO
*/
private static final long serialVersionUID = -3670496550272478781L;
private int DEFAULT_SIZE = 10;
private int capacity;// 保存数组的长度
private Object[] elementData;// 定义一个数组用于保存循环队列的元素
private int front = 0;// 队头
private int rear = 0;// 队尾
// 以默认数组长度创建空循环队列
public LoopQueue() {
capacity = DEFAULT_SIZE;
elementData = new Object[capacity];
}
// 以一个初始化元素来创建循环队列
public LoopQueue(T element) {
this();
elementData[0] = element;
rear++;
}
/**
* 以指定长度的数组来创建循环队列
*
* @param element
* 指定循环队列中第一个元素
* @param initSize
* 指定循环队列底层数组的长度
*/
public LoopQueue(T element, int initSize) {
this.capacity = initSize;
elementData = new Object[capacity];
elementData[0] = element;
rear++;
}
// 获取循环队列的大小
public int size() {
if (isEmpty()) {
return 0;
}
return rear front ? rear - front : capacity - (front - rear);
}
// 插入队列
public void add(T element) {
if (rear == front elementData[front] != null) {
throw new IndexOutOfBoundsException("队列已满的异常");
}
elementData[rear++] = element;
// 如果rear已经到头，那就转头
rear = rear == capacity ? 0 : rear;
}
// 移除队列
public T remove() {
if (isEmpty()) {
throw new IndexOutOfBoundsException("空队列异常");
}
// 保留队列的rear端的元素的值
T oldValue = (T) elementData[front];
// 释放队列的rear端的元素
elementData[front++] = null;
// 如果front已经到头，那就转头
front = front == capacity ? 0 : front;
return oldValue;
}
// 返回队列顶元素，但不删除队列顶元素
public T element() {
if (isEmpty()) {
throw new IndexOutOfBoundsException("空队列异常");
}
return (T) elementData[front];
}
// 判断循环队列是否为空队列
public boolean isEmpty() {
// rear==front且rear处的元素为null
return rear == front elementData[rear] == null;
}
// 清空循环队列
public void clear() {
// 将底层数组所有元素赋为null
Arrays.fill(elementData, null);
front = 0;
rear = 0;
}
public String toString() {
if (isEmpty()) {
return "[]";
} else {
// 如果front rear，有效元素就是front到rear之间的元素
if (front rear) {
StringBuilder sb = new StringBuilder("[");
for (int i = front; i rear; i++) {
sb.append(elementData[i].toString() + ", ");
}
int len = sb.length();
return sb.delete(len - 2, len).append("]").toString();
}
// 如果front = rear，有效元素为front-capacity之间、0-front之间的
else {
StringBuilder sb = new StringBuilder("[");
for (int i = front; i capacity; i++) {
sb.append(elementData[i].toString() + ", ");
}
for (int i = 0; i rear; i++) {
sb.append(elementData[i].toString() + ", ");
}
int len = sb.length();
return sb.delete(len - 2, len).append("]").toString();
}
}
}
public static void main(String[] args) {
LoopQueueString queue = new LoopQueueString("aaaa", 3);
// 添加两个元素
queue.add("bbbb");
queue.add("cccc");
// 此时队列已满
System.out.println(queue);
// 删除一个元素后，队列可以再多加一个元素
queue.remove();
System.out.println("删除一个元素后的队列：" + queue);
// 再次添加一个元素，此时队列又满
queue.add("dddd");
System.out.println(queue);
System.out.println("队列满时的长度：" + queue.size());
// 删除一个元素后，队列可以再多加一个元素
queue.remove();
// 再次加入一个元素，此时队列又满
queue.add("eeee");
System.out.println(queue);
}
}
java for循环的执行顺序和几种常用写法
1：遍历数组的传统方式
/* 建立一个数组 */
int[] integers = {1， 2， 3， 4};
/* 开始遍历 */
for (int j = 0; jintegers.length; j++){
int i = integers[j];
System.out.println(i);
}
2：遍历Collection对象的传统方式
/* 建立一个Collection */
String[] strings = {"A"， "B"， "C"， "D"};
Collection stringList = java.util.Arrays.asList(strings);
/* 开始遍历 */
for (Iterator itr = stringList.iterator(); itr.hasNext();) {
Object str = itr.next();
System.out.println(str);
}
3：遍历数组的简单方式
/* 建立一个数组 */
int[] integers = {1， 2， 3， 4};
/* 开始遍历 */
for (int i : integers) {
System.out.println(i);/* 依次输出“1”、“2”、“3”、“4” */
}
4：遍历数组的简单方式的等价代码
/* 建立一个数组 */
int[] integers = {1， 2， 3， 4};
/* 开始遍历 */
for (int 变量名甲 = 0; 变量名甲integers.length; 变量名甲++) {
System.out.println(integers[变量名甲]);/* 依次输出“1”、“2”、“3”、“4” */
}
5：遍历Collection的简单方式
/* 建立一个Collection */
String[] strings = {"A"， "B"， "C"， "D"};
Collection list = java.util.Arrays.asList(strings);
/* 开始遍历 */
for (Object str : list) {
System.out.println(str);/* 依次输出“A”、“B”、“C”、“D” */
}
6：遍历Collection的简单方式的等价代码
/* 建立一个Collection */
String[] strings = {"A"， "B"， "C"， "D"};
Collection stringList = java.util.Arrays.asList(strings);
/* 开始遍历 */
for (Iterator 变量名乙 = list.iterator(); 变量名乙.hasNext();) {
Object str = 变量名乙.next();
System.out.println(str);/* 依次输出“A”、“B”、“C”、“D” */
}
7：禁止重新赋值
int[] integers = {1， 2， 3， 4};
for (final int i : integers) {
i = i / 2; /* 编译时出错 */
}
8：允许修改状态
Random[] randoms = new Random[]{new Random(1)， new Random(2)， new Random(3)};
for (final Random r : randoms) {
r.setSeed(4);/* 将所有Random对象设成使用相同的种子 */
System.out.println(r.nextLong());/* 种子相同，第一个结果也相同 */
}
9：使用和要被遍历的数组中的元素相同类型的循环变量
int[] integers = {1， 2， 3， 4};
for (int i : integers) {
System.out.println(i);/* 依次输出“1”、“2”、“3”、“4” */
}
10：使用和要被遍历的Collection中的元素相同类型的循环变量
Collection String strings = new ArrayList String();
strings.add("A");
strings.add("B");
strings.add("C");
strings.add("D");
for (String str : integers) {
System.out.println(str);/* 依次输出“A”、“B”、“C”、“D” */
}
11：使用要被遍历的对象中的元素的上级类型的循环变量
String[] strings = {"A"， "B"， "C"， "D"};
Collection String list = java.util.Arrays.asList(strings);
for (Object str : list) {
System.out.println(str);/* 依次输出“A”、“B”、“C”、“D” */
}
12：使用能和要被遍历的对象中的元素的类型自动转换的类型的循环变量
int[] integers = {1， 2， 3， 4};
for (Integer i : integers) {
System.out.println(i);/* 依次输出“1”、“2”、“3”、“4” */
}
java顺序循环选择的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java实现选择排序、java顺序循环选择的信息别忘了在本站进行查找喔。
发布于：2022-12-08，除非注明，否则均为原创文章，转载请注明出处。