प्रौद्योगिकी साझेदारी

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

जावा इत्यस्य उपयोगेन अनुक्रमसारणीयाः सरलं कार्यान्वयनम्

अनुक्रमसारणी रेखीयसंरचना अस्ति या क्रमेण दत्तांशतत्त्वानां संग्रहणार्थं निरन्तरभौतिकपतेः सह भण्डारण-एककस्य उपयोगं करोति । सरणीयां दत्तांशस्य योजनं, विलोपनं, जाँचं, परिवर्तनं च सम्पूर्णं कुर्वन्तु ।

रेखीयसारणीषु सामान्यतया निम्नलिखितविधयः सन्ति ।

सार्वजनिक वर्ग MyArrayList {
निजी int[] सरणी;
निजी int आकारः;
   //पूर्वनिर्धारितनिर्माणविधिः पूर्वनिर्धारितरूपेण स्थानं आवंटयति
SeqList (){ } 1.1.
    // क्रमसारणीयाः अन्तर्निहितक्षमता निर्दिष्टक्षमतायां सेट् कुर्वन्तु
SeqList (int initcapacity){ } 1.1.

   // नूतनानि तत्त्वानि योजयन्तु, पूर्वनिर्धारितरूपेण ते सरणीयाः अन्ते योजिताः भवन्ति
public void add (int डेटा) { }
    //pos स्थाने तत्वं योजयन्तु
public void add (int pos, int डेटा) { }
   // कश्चन तत्त्वः समाविष्टः अस्ति वा इति निर्धारयन्तु
public boolean contains (int toFind) { सत्य वापसी; } .
    // कस्यचित् तत्त्वस्य अनुरूपं स्थानं ज्ञातव्यम्
public int indexOf (int toFind) { वापसी -1; } .
    // तत्त्वं pos स्थाने प्राप्नुत
सार्वजनिक int प्राप्त (int pos) { return -1; } .
   // pos स्थाने तत्त्वं मूल्ये सेट् कुर्वन्तु
public void set (int pos, int मूल्य) { }
    //कीवर्ड कीलस्य प्रथमा आगमनं विलोपयन्तु
public void हटाओ (int toRemove) { }
   // क्रमसारणीयाः दीर्घतां प्राप्नुत
public int आकार () { return 0; } .
    //अनुक्रमसारणीं स्वच्छं कुर्वन्तु
public void स्पष्ट () { } .
   
   //अनुक्रम तालिका मुद्रयतु
public void प्रदर्शन () { } .
}

तदनन्तरं उपर्युक्तविधिना int प्रकारस्य क्रमसारणीं कार्यान्वितं कुर्वन्तु ।

import java.util.Arrays;
public class MyArrayList {
    private int[] elem;
    private int usedSize;
    private static final int DEFAULT_SIZE = 10;
    public MyArrayList(){
        elem = new int[DEFAULT_SIZE];
    }
    public MyArrayList(int initCapacity){
        elem = new int[initCapacity];
    }
 
    private boolean checkCapacity(){
        if(this.usedSize == elem.length){
            return true;
        }
        return false;
    }
 
    public void display(){
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i] + " ");
        }
    }
    public void add(int data){
        if(checkCapacity()){
            this.elem = Arrays.copyOf(this.elem,2*elem.length);
        }
        this.elem[this.usedSize] = data;
        this.usedSize++;
        return;
    }
    public void add(int pos,int data){
        if(pos > this.usedSize || pos < 0){
            throw new PosOutOfBoundsException("插入位置错误！");
        }
        if(checkCapacity()){
            this.elem = Arrays.copyOf(this.elem,2*elem.length);
        }
        for (int i = this.usedSize - 1; i >=pos ; i--) {
            elem[i+1] = elem[i];
        }
        this.elem[pos] = data;
        this.usedSize++;
        return;
    }
 
    public boolean contains(int data){
        for (int i = 0; i < this.usedSize; i++) {
            if(this.elem[i] == data){
                return true;
            }
        }
        return false;
    }
 
    public int indexof(int data){
        for (int i = 0; i < this.usedSize; i++) {
            if(this.elem[i] == data){
                return i;
            }
        }
        return -1;
    }
    public int get(int pos){
        if(pos >= this.usedSize || pos < 0){
            throw new PosOutOfBoundsException("输入的位置错误！");
        }
        return this.elem[pos];
    }
    public void set(int pos,int data){
        if(pos >= this.usedSize || pos < 0){
            throw new PosOutOfBoundsException("输入的位置错误！");
        }
        this.elem[pos] = data;
    }
    public int size(){
        return this.usedSize;
    }
    public void remove(int data){
        if(this.contains(data)){
            int pos = this.indexof(data);
            for (int i = pos; i < this.usedSize - 1; i++) {
                this.elem[pos] = this.elem[pos+1];
            }
            this.usedSize--;
        }else{
            throw new PosOutOfBoundsException("没有该元素");
        }
    }
    public void clear(){
        this.usedSize = 0;
        return;
    }
}

ArrayList इत्यस्य परिचयः

संग्रहणरूपरेखायां ArrayList एकः साधारणः वर्गः अस्ति यः List अन्तरफलकं कार्यान्वितं करोति विशिष्टरूपरेखाचित्रं निम्नलिखितम् अस्ति ।

• ArrayList सामान्यरूपेण कार्यान्वितं भवति तथा च उपयोगात् पूर्वं उदाहरणं करणीयम् ।
• ArrayList RandomAccess अन्तरफलकं कार्यान्वितं करोति, यत् सूचयति यत् ArrayList यादृच्छिकप्रवेशं समर्थयति
• ArrayList Cloneable अन्तरफलकं कार्यान्वितं करोति, यत् सूचयति यत् ArrayList क्लोन् कर्तुं शक्यते
• ArrayList Serializable अन्तरफलकं कार्यान्वितं करोति, यत् सूचयति यत् ArrayList क्रमाङ्कनं समर्थयति
• Vector इत्यस्य विपरीतम् ArrayList थ्रेड्-सुरक्षितं नास्ति तथा च एकस्मिन् थ्रेड् इत्यस्मिन् उपयोक्तुं शक्यते बहु-थ्रेड् इत्यत्र भवान् Vector अथवा इति चिन्वितुं शक्नोति
• CopyOnWriteArrayList इति
• ArrayList इत्यस्य अधः स्तरः एकः निरन्तरः स्थानः अस्ति तथा च गतिशीलरूपेण विस्तारितुं शक्यते इयं गतिशीलप्रकारस्य अनुक्रमसूची अस्ति ।

ArrayList इत्यस्य उपयोगः कथं भवति

ArrayList कन्स्ट्रक्टर्

ArrayList इत्यस्मिन् कन्स्ट्रक्टर् मेथड्:

ArrayList (); //कोऽपि पैरामीटर निर्माणं नास्ति

ArrayList (संग्रह<? extends E> c); //ArrayList इत्यस्य निर्माणार्थं अन्येषां संग्रहाणां उपयोगं कुर्वन्तु

ArrayList(int initialCapacity); //अनुक्रमसारणीयाः प्रारम्भिकक्षमता निर्दिशन्तु

कोड उदाहरणम् : १.

public class Test {
    public static void main(String[] args) {
        List<Integer> list1 = new ArrayList<>();//无参构造
        List<Integer> list2 = new ArrayList<>(10);//指定容量
        list2.add(1);
        list2.add(2);
        list2.add(3);
        List<Integer> list3 = new ArrayList<>(list2);//利用其他 Collection 构建 ArrayList
    }
}

ArrayList इत्यत्र सामान्यक्रियाः

पुच्छ प्लग

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();//无参构造
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list);
    }
}

निर्दिष्टस्थाने तत्त्वं सम्मिलितं कुर्वन्तु

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(1,4);
        System.out.println(list);
    }
}

अन्यस्य क्रमसूचिकातः इन्सर्ट् एलिमेण्ट्स् समाप्तं कुर्वन्तु

public class Test {
    public static void main(String[] args) {
        List<Integer>  list1 = new ArrayList<>();
        list1.add(4);
        list1.add(5);
        list1.add(6);
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.addAll(list1);
        System.out.println(list);
    }
}

निर्दिष्टस्थाने तत्त्वं विलोपयन्तु

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.remove(1);
        System.out.println(list);
    }
}

निर्दिष्टदत्तांशं विलोपयन्तु

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.remove(new Integer(2));
        System.out.println(list);
    }
}

निर्दिष्टस्थाने तत्त्वं प्राप्नुवन्तु

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list.get(1));
    }
}

निर्दिष्टस्थाने तत्त्वं नूतनदत्तांशं प्रति सेट् करोति

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.set(1,4);
        System.out.println(list);
    }
}

क्रमसूचीं स्पष्टं कुर्वन्तु

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.clear();
        System.out.println(list);
    }
}

क्रमसूचौ कश्चन तत्त्वः अस्ति वा इति निर्धारयन्तु

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list.contains(2));
        System.out.println(list.contains(4));
    }
}

प्रथमस्य निर्दिष्टस्य तत्त्वस्य अनुक्रमणिकां प्रत्यागच्छति

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(1);
        System.out.println(list.indexOf(1));
    }
}

अन्तिमनिर्दिष्टस्य तत्त्वस्य अनुक्रमणिकां प्रत्यागच्छति

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(1);
        System.out.println(list.lastIndexOf(1));
    }
}

सूचीयाः भागं अवरुद्धं कुर्वन्तु

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list.subList(0,2));
    }
}

ArrayList इत्यस्य भ्रमणस्य त्रयः उपायाः

ArrayList इति त्रयः प्रकाराः भ्रमितुं शक्यन्ते: for loop + subscript, foreach enhanced loop, and using iterators इति

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        //使用fori遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i));
        }
        System.out.println();
        //使用foreach遍历
        for(Integer integer:list){
            System.out.print(integer);
        }
        System.out.println();
        //使用迭代器遍历
        Iterator<Integer> it = list.listIterator();
        while(it.hasNext()){
            System.out.print(it.next());
        }
    }
}

संचालन परिणाम : १.

ArrayList इत्यस्य परिदृश्यस्य उपयोगः

घुमावदार एल्गोरिदम

ताशक्रीडायाः एकं स्तम्भं यादृच्छिकरूपेण संयोजयित्वा त्रयाणां जनानां कृते वितरन्तु, प्रत्येकं पञ्च ताशपत्राणि सन्ति ।

एल्गोरिदम् इत्यस्य मूलसङ्केतस्य स्थानं : १.

shufflecards · सदैव मीठजलस्य मत्स्य/जावा क्लासिक उदाहरणानि - कोड मेघः - मुक्त स्रोतः चीन (gitee.com)

यांग हुई त्रिकोण

विषयविवरणम् : १.

संहिता : १.

public class Test {
    public static List<List<Integer>> generate(int numRows) {
        List<List<Integer>> list = new LinkedList<>();
        for (int i = 0; i < numRows; i++) {
            List<Integer> row = new LinkedList<>();
            for (int j = 0; j < i + 1; j++) {
                if (j == 0 || i == j) {
                    row.add(1);
                } else {
                    row.add(list.get(i - 1).get(j - 1) + list.get(i - 1).get(j));
                }
            }
            list.add(row);
        }
        return list;
    }
 
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int numRows = scanner.nextInt();
        List<List<Integer>> list = generate(numRows);
        for (int i = 0; i < numRows; i++) {
            for (int j = 0; j < i + 1; j++) {
                System.out.print(list.get(i).get(j) + " ");
            }
            System.out.println();
        }
    }
}

परिणामग्राफं चालयन् : १.