Проверка отсортированного массива для дубликатов

Question

У меня есть отсортированный массив, который я хочу проверить для повторных записей. Проблема в том, что мне нужно знать, где дубликат был как многомерный массив, и мне нужно также удалить вторую запись. Кроме того, в конце концов, у меня должен быть массив, заполненный значениями, поэтому просто переписывание дубликатов с помощью некоторого макета не будет работать. Я прочитал около Array.utils, делая трюк, но я не хочу импортировать какие-либо другие библиотеки, и Array.utils не распознается, поэтому я должен был импортировать это.

Я также попытался написать небольшую функцию себя

 Integer iIndex = 1; 
    while (keepRunning2){ 
     if(phoneNameNumber[iIndex][0].equals(phoneNameNumber[iIndex-1][0])){ 
      keepRunning = true; 
      tmp = new String[phoneNameNumber.length-1][2]; 
      int k = 0; 
      int t=0; 
      while(keepRunning){ 
       Log.wtf("running",String.valueOf(iIndex) + ":" + String.valueOf(k)); 
       tmp[t][0] = phoneNameNumber[k][0]; 
       tmp[t][1] = phoneNameNumber[k][1]; 
       if(k!=i-1){ 
        k++; 
        t++; 
       }else{ 
        k=k+2; 
        t++; 
       } 
       if(t==tmp.length-1) 
        keepRunning=false; 

      } 
      phoneNameNumber = null; 
      phoneNameNumber = new String[tmp.length][2]; 
      phoneNameNumber = tmp; 
     } 
     if(!(iIndex < phoneNameNumber.length-1)){ 
      keepRunning2 = false; 
     } 
     iIndex++; 
    } 

Buuuut ... первое, что нужно, как 10 лет, чтобы закончить это, и как это для пользовательского интерфейса приложения вы можете увидеть, что оно должно быть alittle быстрее + ​​по какой-то причине после обработки все это возвращается обратно, пока keeppRunning2 'd никогда не будет установлен в false.

Так кто-нибудь знает решение?

и если С.Б. хотите знать, где данные поступают от: ЭРВО деятельности

import android.app.ActionBar; 
import android.app.Activity; 
import android.app.DialogFragment; 
import android.content.ContentResolver; 
import android.content.Intent; 
import android.database.Cursor; 
import android.os.AsyncTask; 
import android.os.Bundle; 
import android.provider.ContactsContract; 
import android.support.v7.app.AppCompatActivity; 
import android.util.Log; 
import android.view.Menu; 
import android.view.MenuItem; 
import android.view.View; 
import android.widget.AdapterView; 
import android.widget.ArrayAdapter; 
import android.widget.Button; 
import android.widget.CheckBox; 
import android.widget.CheckedTextView; 
import android.widget.EditText; 
import android.widget.LinearLayout; 
import android.widget.RadioGroup; 
import android.widget.Spinner; 
import android.widget.TextView; 
import android.widget.Toast; 

import java.sql.Array; 
import java.util.ArrayList; 
import java.util.Arrays; 
import java.util.Comparator; 
import java.util.List; 
import java.util.concurrent.ExecutionException; 

/** 
* Created by **** on 19.07.2016. 
*/ 
public class newChatActivity extends Activity implements  View.OnClickListener,AdapterView.OnItemSelectedListener{ 

Button bCreateChat; 
Button bCancelChat; 
EditText tchat_name; 
//EditText tmembers; 
CheckBox cBoxPrivateChat; 
Spinner memberSpinner; 
String members = ""; 
String lastContactName = ""; 
List<String> nameList,number; 
String[][]phoneNameNumber,tmp; 
String[] sortedNames; 
Integer i = 0; 
Integer memberCount = 0; 
Boolean keepRunning = true; 
Boolean keepRunning2 = true; 

private static final String[] PROJECTION = new String[] { 
     ContactsContract.CommonDataKinds.Phone.CONTACT_ID, 
     ContactsContract.Contacts.DISPLAY_NAME, 
     ContactsContract.CommonDataKinds.Phone.NUMBER 
}; 



@Override 
public void onCreate(Bundle savedInstanceState){ 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.new_chat); 
    setTitle("Add New Chat"); 

    bCreateChat = (Button) findViewById(R.id.bCreateChat); 
    bCancelChat = (Button) findViewById(R.id.bChatCance); 
    tchat_name = (EditText) findViewById(R.id.tchat_name); 
    cBoxPrivateChat = (CheckBox) findViewById(R.id.cBoxprivChat); 
    memberSpinner = (Spinner) findViewById(R.id.memberSpinner); 


    bCreateChat.setOnClickListener(this); 
    bCancelChat.setOnClickListener(this); 

    loadAllContacts(); 
    sortedNames = new String[phoneNameNumber.length]; 
    Integer iIndex = 1; 
    while (keepRunning2){ 
     if(phoneNameNumber[iIndex][0].equals(phoneNameNumber[iIndex-1][0])){ 
      keepRunning = true; 
      tmp = new String[phoneNameNumber.length-1][2]; 
      int k = 0; 
      int t=0; 
      while(keepRunning){ 
       Log.wtf("running",String.valueOf(iIndex) + ":" + String.valueOf(k)); 
       tmp[t][0] = phoneNameNumber[k][0]; 
       tmp[t][1] = phoneNameNumber[k][1]; 
       if(k!=i-1){ 
        k++; 
        t++; 
       }else{ 
        k=k+2; 
        t++; 
       } 
       if(t==tmp.length-1) 
        keepRunning=false; 


      } 
      phoneNameNumber = null; 
      phoneNameNumber = new String[tmp.length][2]; 
      phoneNameNumber = tmp; 
     } 
     if(!(iIndex < phoneNameNumber.length-1)){ 
      keepRunning2 = false; 
     } 
     iIndex++; 
    } 

    for(int i = 0;i<phoneNameNumber.length;i++){ 
     sortedNames[i] = phoneNameNumber[i][0]; 
    } 
    ArrayAdapter<String> spinnerAdapter = new ArrayAdapter<String>(this,android.R.layout.simple_spinner_item,sortedNames); 
    spinnerAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); 
    memberSpinner.setAdapter(spinnerAdapter); 
    memberSpinner.setOnItemSelectedListener(this); 



} 


@Override 
public void onClick(View v) { 
    switch (v.getId()){ 
     case R.id.bCreateChat: 
       if (!tchat_name.getText().toString().isEmpty()&&!members.isEmpty()) { 
        if(cBoxPrivateChat.isChecked()){ 
         createChat("name=" + tchat_name.getText().toString() + "&members=" + members + ScrollingActivity.Identifier + "#"); 
        } 
       } else{ 
        Toast.makeText(this,"Keine Daten Eingegeben",Toast.LENGTH_SHORT).show(); 
       } 
      break; 
     case R.id.bChatCance: 
      this.finish(); 
      break; 
     default: 
      if(v.getId() > 2000000){ 
       members = members.replace("#" + number.get(v.getId() - 2000000) + "#",""); 
       TextView delText = (TextView) findViewById(v.getId()); 
       delText.setVisibility(View.GONE); 
       memberCount = memberCount - 1; 
       if(memberCount <= 1){ 
        cBoxPrivateChat.setEnabled(true); 
       } 
      } 
    } 
} 

public void createChat(String Data){ 
    try { 
     Boolean b = new createNewCHat().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,ScrollingActivity.ServerLocation + "/alterChat.php", Data).get(); 
    } catch (InterruptedException e) { 
     e.printStackTrace(); 
    } catch (ExecutionException e) { 
     e.printStackTrace(); 
    } 
    Intent intent = new Intent(getApplicationContext(), ScrollingActivity.class); 
    intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); 
    intent.putExtra("EXIT", true); 
    startActivity(intent); 
} 

@Override 
public void onItemSelected(AdapterView<?> parent, View view, int position, long id) { 
    if(position != 0 && !cBoxPrivateChat.isChecked()) { 
     members = members + "#" + number.get(position) + "#"; 
     TextView MemberText = new TextView(this); 
     MemberText.setId(2000000 + position); 
     MemberText.setText(phoneNameNumber[position][0] + " " + phoneNameNumber[position][1]); 
     LinearLayout memberLayout = (LinearLayout) findViewById(R.id.membersLayout); 
     RadioGroup.LayoutParams params = new RadioGroup.LayoutParams(RadioGroup.LayoutParams.MATCH_PARENT, 100); 
     memberLayout.addView(MemberText, params); 
     MemberText.setOnClickListener(this); 
     memberCount++; 
     if(memberCount > 1){ 
      cBoxPrivateChat.setEnabled(false); 
      cBoxPrivateChat.setChecked(false); 
     } 
    } else if(position != 0 && cBoxPrivateChat.isChecked() && members.equals("")){ 
     members = members + "#" + number.get(position) + "#"; 
     TextView MemberText = new TextView(this); 
     MemberText.setId(2000000 + position); 
     MemberText.setText(phoneNameNumber[position][0] + " " + phoneNameNumber[position][1]); 
     LinearLayout memberLayout = (LinearLayout) findViewById(R.id.membersLayout); 
     RadioGroup.LayoutParams params = new RadioGroup.LayoutParams(RadioGroup.LayoutParams.MATCH_PARENT, 100); 
     memberLayout.addView(MemberText, params); 
     MemberText.setOnClickListener(this); 
     memberCount++; 
    } 
} 

@Override 
public void onNothingSelected(AdapterView<?> parent) { 

} 


public void loadAllContacts(){ 
    nameList = new ArrayList<String>(); 
    number = new ArrayList<String>(); 
    ContentResolver cr = getContentResolver(); 
    Cursor cursor = cr.query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI, PROJECTION, null, null, null); 
    if (cursor != null) { 
     try { 
      final int nameIndex = cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME); 
      final int numberIndex = cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER); 


      nameList.add(0,"Select chat members"); 
      number.add(0,""); 

      while (cursor.moveToNext()) { 
       if(!cursor.getString(nameIndex).equals(lastContactName)){ 
        nameList.add(cursor.getString(nameIndex)); 
        number.add(cursor.getString(numberIndex)); 
        lastContactName = cursor.getString(nameIndex); 
       } 
      } 
     } finally { 
      cursor.close(); 

     } 
     phoneNameNumber = new String[nameList.size()][2]; 

     for(int i = 0; i<nameList.size();i++){ 
      phoneNameNumber[i][0] = nameList.get(i); 
      phoneNameNumber[i][1] = number.get(i); 
     } 

     Arrays.sort(phoneNameNumber, new Comparator<String[]>() { 
      @Override 
      public int compare(final String[] entry1, final String[] entry2) { 
       final String time1 = entry1[0]; 
       final String time2 = entry2[0]; 
       return time1.compareTo(time2); 
      } 
     }); 

    } 

} 
} 

ой и кстати кто-нибудь знает, почему есть дубликаты в массиве? потому что, если я просто использую имена списков на spinner, у меня нет дубликатов

Answer 1

, так что вы, вероятно, хотели некоторые функции, как это:

(но я не понимаю вашего «Я должен знать, где дубликат был» ... почему А также ваш код не использует другое измерение? в любом случае, только [0] сравнивается ... так что я, что в подражать мой код тоже, но, возможно, это не то, что вы хотели?)

import java.util.Arrays; // Maybe all of your problem is that you had typo in import? 
// This is language standard stuff, available everywhere IMHO 

    /** 
    * Removes duplicates and nulls from sorted array, first item (sortedArray[i][0]) is considered 
    * for duplicates search, rest of values sortedArray[i][1..n] is not considered at all. 
    * 
    * @param sortedArray 
    *   sorted 2D String array, can have any 1 <= length in second dimension. 
    * @return items with duplicate in [i][0] or null will be removed from result array. 
    */ 
    public static String[][] removeDuplicateOrNullItems(final String[][] sortedArray) { 
     // validate input 
     if (null == sortedArray || sortedArray.length <= 1) { 
      return sortedArray; // garbage in, garbage out 
     } 
     // search for first duplicate (if any) 
     int i = 0; 
     while (++i < sortedArray.length) { 
      if (null == sortedArray[i][0] || sortedArray[i][0].equals(sortedArray[i - 1][0])) { 
       break; 
      } 
     } 
     if (i == sortedArray.length) { 
      return sortedArray; // no duplicate found, return input 
     } 
     // First duplicate is at index i, now compact the rest of array content (overwriting dupes) 
     int newi = i; // will serve both as count of unique values, and compact-writing index 
     while (++i < sortedArray.length) { 
      if (null == sortedArray[i][0] || sortedArray[i][0].equals(sortedArray[i - 1][0])) { 
       continue; // another duplicate, skip this one 
      } 
      sortedArray[newi++] = sortedArray[i]; // valid value, compact it 
     } 
     return Arrays.copyOf(sortedArray, newi); // return the compacted result 
    } 

// demo how to call it: 

     String[][] in = {{"A1", "A2"}, {"A1", "dupA"}, {null, null}, {"B1", "B2"}, {"B1", "dupB1"}, {"B1", "dupB2"}, {"C1", "C2"}}; 
//  String[][] in = {{"A1", "A2", "A3"}, {"B1", "B2", "B3"}}; 
//  String[][] in = null; 

     String[][] out = removeDuplicateOrNullItems(in); 

Я попытался прокомментировать его немного, чтобы дать вам идею что он делает ... хотя использование отладчика и его пошаговое построение несколько раз может помочь намного больше.

---

Если вы действительно хотите, чтобы избежать java.util.Arrays, то последний return Arrays.copyOf... следует заменить следующим образом:

final String[][] result = new String[newi][sortedArray[0].length]; 
    for (i = 0; i < newi; ++i) result[i] = sortedArray[i]; 
    return result; 

---

добавил:
о тех, 3 задания:

 phoneNameNumber = null; 
     phoneNameNumber = new String[tmp.length][2]; 
     phoneNameNumber = tmp; 

Я не знаю, что вы уже знаете про прог таран, так что это может быть сложно.

phoneNameNumberString[][] тип, который является своего рода адресом (указателем) для размещения в памяти, где хранится массив (количество измерений не важно).

Таким образом, вы сначала установить его null, затем новое выделенное пространство, и, наконец, место, где tmp наведен уже (обмен же массив с tmp). Вторая строка с распределением новой памяти бесполезна, она будет перезаписана сразу третьей строкой, а вновь выделенная память будет доступна для GC (Garbage Collector).

Если вы хотите скопировать значения из tmp в новую выделенную область в памяти (реальную копию), вы должны сделать цикл for и назначить phoneNameNumber[i][j] = tmp[i][j];. Затем это разделило бы с tmp только указатели на String, что нормально в Java, так как String является неизменным (не может изменить значение, поэтому, если вы сохраняете адрес одной строки вокруг, вы можете быть уверены, что это содержимое не было измените, даже если какая-то другая часть кода работает с этим указателем).

Если бы только phoneNameNumber[i] = tmp[i];, чтобы скопировать его, это будет выглядеть на первый взгляд одинаковые (значения в новом phoneNameNumber будет такой же, как в tmp. Но есть разница, теперь phoneNameNumber и tmp разделит также две строки внутренней крошечные массивы Итак, после такой копии, если бы вы сделали tmp[0][1] = null;, phoneNameNumber[0][1] также внезапно содержал бы null (поскольку эта область памяти, в которой хранятся эти указатели на строки, является общей, поэтому вы записываете нулевой указатель там для обеих переменных).

Или для копирования (истинной копии) используются методы java.util.Arrays.copy***.

Первая строка, устанавливающая ее на null, на самом деле иногда используется в программах Java, чтобы отметить некоторую память для GC как «выпущенную», если вы знаете, что больше не будете ее использовать.

Как вы перезаписать phoneNameNumber с другим указателем сразу, это бесполезно, GC будет собирать оригинальную память также, если вы будете только непосредственно присвоить tmp к нему (теряет старое значение = готов к GC). На самом деле производительность в этом случае означает, что промежуточный шаг обнуления старого значения вредит JVM + GC, поскольку он разрешает два назначения вместо одного, и результат будет таким же.

Как вы можете видеть, меня не волнует, копирую ли или разделяю части исходного массива, используя то, что проще. Таким образом, этот метод написан таким образом, что он будет изменять исходный ввод. Если вы хотите сохранить его в неприкосновенности (и получить результат в другом массиве), вы должны вызвать его с копией входного массива, пусть это беспорядок с копией:
String[][] out = removeDuplicateOrNullItems(Arrays.copyOf(in, in.length));
EDIT: BUG ^^ этот copyOf или in.clone() не является глубокой копией, создавая копии на всех уровнях измерения, но только создавая копию верхнего массива, разделяя все ниже между ними.

Пример в коде:

// INIT 

String[][] in = {{"A1", "A2"}, {"B1", "B2"}}; 
// in is array of 2 references (pointers) at String[] value. 
// Let's say in@adr1 = [@r1, @r2] (at address @adr1 in memory) 
// @r1 = array of two references to Strings [@"A1", @"A2"], @r2 = [@"B1", @"B2"] 
String[][] inCopy = in.clone(); 
// inCopy has copy of top level array (content of in@adr1) at address @adr2 
// inCopy@adr2 = [@r1, @r2]; so this is in new memory, 
// but the values are old @r1 and @r2, sharing the second level arrays with "in" 

// modification CASE 1 

String[] x = {"X1", "X2"}; // x@adr3 = [@"X1", @"X2"] 
in[0] = x; 
// in@adr1 = [x@adr3, @r2], so in = [[X1, X2], [B1, B2]] 
// inCopy@adr2 = [@r1, @r2], so inCopy = [[A1, A2], [B1, B2]] 

// modification CASE 2 (on deeper level, where clone/copyOf didn't create copy) 

in[1][0] = "X"; // @r2[0] modified to contain @"X"; 
// in@adr1 = [x@adr3, @r2], @r2 = [@"X", @"B2"], in = [[X1, X2], [X, B2]] 
// inCopy@adr2 = [@r1, @r2] (same @r2!), so inCopy = [[A1, A2], [X, B2]] 

Как можно видеть, во втором случае InCopy модифицируют путем модификации в [1] [0].Чтобы предотвратить это, вы должны скопировать многомерные массивы на глубину:

String[][] in = {{"A1", "A2"}, {"B1", "B2"}}; 
String[][] inCopy = new String[in.length][in[0].length]; 
// inner arrays of inCopy are cloned to new memory, not shared with "in" 
for (int i = 0; i < in.length; ++i) { 
    inCopy[i] = in[i].clone(); 
} 

Но вы можете принять это как предупреждение, что это не так уж трудно создать большую ошибку в своих предположениях. :/Всегда проверяйте свой код ...: D (автоматическое тестирование с помощью Unit Tests идеально подходит для таких случаев). Кроме того, после написания первой хорошей версии, никогда не помешает шаг за шагом в отладчике шаг за шагом, просто чтобы убедиться, что он работает так, как вы предполагали (плюс это помогает многому научиться).

---

Обычно, когда вы создаете свои собственные методы, это немного лучше действовать на входах как неизменные ценности, и не изменять их (в идеале мой метод позволит создать эту копию массива в самом начале его). Это приводит к меньшему количеству ошибок при сбое позже, когда вы вызываете ваш API, думая, что он вернет только измененный массив в качестве новой копии, но не изменит входной. (Класс Java Date, как известно, меня не устраивает, когда я запрашиваю какое-то значение, хранящееся для пользовательского интерфейса, и делаю некоторые вычисления с ним, чтобы увидеть, будет ли, например, дата истекает через 14 дней, а затем мне интересно, почему значение в пользовательском интерфейсе изменилось (так как я делал расчет по исходной памяти, а не копировал ее). String неизменен, поэтому всякий раз, когда вы меняете строку на какое-то новое значение, вы можете поспорить, что вы получили новый указатель, а если другой код держит старую прямую напрямую , он все еще видит старую строку. = менее неожиданно для программистов, которые постоянно торопятся.

Хммм ... это слишком долго. Если вы не поняли, о чем я говорю, попробуйте найти как работает память компьютера, что такое распределение памяти, а затем в Java, как хранятся переменные. found something here, looks like free lecture notes from uni course. Если вы новичок в программировании, это может быть q uite запутывает сначала, но затем ищет некоторые детские книги, описывающие работу компьютера или некоторые ранние книги по программированию (эпоха 1970-1990 годов), которые должны дать вам хорошую основу для понимания того, что происходит внутри, когда вы будете больше читать о JVM ,

Answer 2

Java - это мощный язык, потому что он имеет полезные библиотеки. Я рекомендую использовать ArrayList, так как это повысит эффективность, производительность и сложность.

Это действительно лучшее, что я могу придумать, если вы хотите решить эту проблему без использования этих библиотек.

// I don't know what's your phoneNameNumber, but I assume it is 2D string array: 
String[][] phoneNameNumber = new String[][]; 
String duplicatedIndicesString = ""; 

// Loop through phoneNameNumber 
for (int i=0; i<phoneNameNumber.length; i++) { 
    // Find duplicates 
    for (int i2=0; i<phoneNameNumber.length; i2++) { 
     boolean duplicated = true; 

     for (int j=0; j<phoneNameNumber[i2].length; j++) { 
      if (phoneNameNumber[i][j].equals(phoneNameNumber[i2].j) == false) { 
       // Not duplicate for this i2 
       duplicated = false; 
       break; 
      } 
     } 

     if(duplicated == true) { 
      duplicatedIndicesString += i2; 
      if (i2!=phoneNameNumber.length-1) { 
       // Store duplicated index for later dynamic allocation.. 
       duplicatedIndicesString += ","; 
      } 
     } 
    } 
} 

// Now let's copy results to a new array. 
String[] duplicatedIndicesStringArray = duplicatedIndicesString.split(","); 
String[][] resultPhoneNameNumber = new String[phoneNameNumber.length - dupicatedIndices.length][2]; 
int resultIndex = 0; 

for (int i=0; i<phoneNameNumber.length; i++) { 
    boolean duplicated = false; 

    for (j=0; j<duplicatedIndicesStringArray.length; j++) { 
     if (Integer.parseInt(duplicatedIndicesStringArray[j]) == i) { 
      duplicated = true; 
      break; 
     } 
    } 

    if (duplicated == false) { 
     resultPhoneNameNumber[resultIndex] = phoneNameNumber[i]; 
     resultIndex++; 
    } 
} 

Это, вероятно, самый уродливый код, который я написал некоторое время. Я сделал это, потому что я взял слишком много утреннего кофе. Подумайте, прежде чем вводить код.